@mnemom/mnemom 0.17.33 → 0.17.34-next.2

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

@@ -0,0 +1,208 @@
+// GENERATED from shared/durable-contract/src/vectors.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * Golden vectors for the recipes S1 freezes, computed independently with node:crypto (a separate
+ * canonical-JSON and AES-256-GCM implementation, scratchpad s1gen/gen.cjs) and pinned here. The
+ * tests recompute each with this package's code; a mismatch is a contract break.
+ */
+export const CONTRACT_VECTOR = {
+    dek_b64url: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8",
+    iv_b64url: "oKGio6Slpqeoqaqr",
+    session_id: "11111111-2222-4333-8444-555555555555",
+    contract: {
+        statement: "Ship the M1 durable contract and keep every flag inert when off.",
+        requirements: ["tests pass", "no prod change"],
+        allowed_paths: ["shared/durable-contract/**"],
+        forbidden_paths: [".github/**"],
+    },
+    plaintext: '{"allowed_paths":["shared/durable-contract/**"],"forbidden_paths":[".github/**"],"requirements":["tests pass","no prod change"],"statement":"Ship the M1 durable contract and keep every flag inert when off."}',
+    statement_hash: "51d9393d4b1b22b84e4fe45acb3e4f3c561e75d03701771aa40c805a5146f939",
+    requirements_hash: "566af8b913e8827626360e11b53b0356f9784508e3e51e36c9d6d4ce5b64bb31",
+    envelopes: [
+        {
+            charter_version: 1,
+            envelope: "v1.oKGio6Slpqeoqaqr.nTodQSmkddoGOveycxKz_Er3e2P61jAJ-CFC8w3KF223WySQwVYhXDzoK-IjWN7VZX0pOgC5fhokMFQuxQTtw5aG3k0ewo2UnJedN6Xk7ufhKdnBtLTwCIsYW_TF6W-u1KZfznDa_LvuunUjp6TPRktwEdyxUbtfR66ww9F3r2HnYsQepyftclkt3LEwGfm_-PnZA9vwt73dqciHzqVYTuZ7cN_CGCF19ipKTAvy3YQSVt39dAPcR6LkGlg7onY5UUQ46Re53oPTMiapZwZPU3bq5U_b2kWGfRebX73T3g",
+        },
+        {
+            charter_version: 2,
+            envelope: "v1.oKGio6Slpqeoqaqr.nTodQSmkddoGOveycxKz_Er3e2P61jAJ-CFC8w3KF223WySQwVYhXDzoK-IjWN7VZX0pOgC5fhokMFQuxQTtw5aG3k0ewo2UnJedN6Xk7ufhKdnBtLTwCIsYW_TF6W-u1KZfznDa_LvuunUjp6TPRktwEdyxUbtfR66ww9F3r2HnYsQepyftclkt3LEwGfm_-PnZA9vwt73dqciHzqVYTuZ7cN_CGCF19ipKTAvy3YQSVt39dAPcR6LkGlg7onY5UUQ46Re53oPTMiapZwZPLBiJm0K86YthUHE-qc35MQ",
+        },
+    ],
+};
+/** One journal row per writer class, each hashed as a genesis row (prev_hash = 64 zeros). */
+export const EVENT_PREIMAGE_VECTORS = [
+    {
+        writer: "executor",
+        refs: {
+            spawn_id: "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
+        },
+        detail: "executor.spawned spawn_id=aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
+        preimage: '{"detail_sha256":"9869cd123386f64b766dbff0fcf4a6f7d35f4bf9f6eec5594055e77c5fe0d4b0","epoch":2,"idempotency_key":"spawn:11111111-2222-4333-8444-555555555555:2:aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee","kind":"executor.spawned","prev_hash":"0000000000000000000000000000000000000000000000000000000000000000","principal_ref":null,"refs_sha256":"80280db047606c26674cc10fa3e08ac9dabbde08c3958116f31f0211f15b31c9","seq":3,"session_id":"11111111-2222-4333-8444-555555555555","ts":"2026-10-16T12:00:00.123000Z","v":1}',
+        hash: "a54e7c93b2bc865905a57755b02b0af397b6b281caab922c411de689a2e2273d",
+    },
+    {
+        writer: "gateway",
+        refs: {
+            admitted_epoch: 2,
+            current_epoch: 3,
+        },
+        detail: "lease.zombie_call admitted_epoch=2 current_epoch=3",
+        preimage: '{"detail_sha256":"9ee4f5d787302fe3464b96cc8d38cfffe049c503fea6292db98e68135ceafd9b","epoch":3,"idempotency_key":"zombie:req-0001","kind":"lease.zombie_call","prev_hash":"0000000000000000000000000000000000000000000000000000000000000000","principal_ref":null,"refs_sha256":"351c59d5e2d263f0e3edc09e0ad8bf205b4fb0ba12898c5b5e666e7edf821eb4","seq":4,"session_id":"11111111-2222-4333-8444-555555555555","ts":"2026-10-16T12:00:01.000000Z","v":1}',
+        hash: "db229bf5c9d46295dd6e3b282750ddfd291ea164c2b8fced450790fc141d9c39",
+    },
+    {
+        writer: "api",
+        refs: {
+            durable_mode: "locked",
+        },
+        detail: "session.registered durable_mode=locked",
+        preimage: '{"detail_sha256":"eab692f69df0b5aa9984cd233af2135fa08329f21236f6a095d9a289002a28b0","epoch":0,"idempotency_key":"tr:11111111-2222-4333-8444-555555555555:session.registered:0","kind":"session.registered","prev_hash":"0000000000000000000000000000000000000000000000000000000000000000","principal_ref":"9999999999999999999999999999999999999999999999999999999999999999","refs_sha256":"b62d326eeec5672858e7bd2cfa73a0520968329af7e405a0d8cf86cd6cecd891","seq":1,"session_id":"11111111-2222-4333-8444-555555555555","ts":"2026-10-16T11:59:00.000000Z","v":1}',
+        hash: "13acfe4d0979d989464c0a71fbae440afb4d6056eaf770db2b27d39e1793d6d3",
+    },
+];
+export const PRINCIPAL_REF_VECTOR = {
+    salt_utf8: "salt-0123456789abcdef",
+    principal_uid: "user-uid-1",
+    principal_ref: "beb9218556929a56f74799caabfb6679f829cbc1521d139fdb710a66ab2e29b6",
+};
+export const SPEC_HASH_VECTOR = {
+    spec: {
+        v: 1,
+        cwd: "/Users/dev/repo",
+        plugin: "bundled-mnemom",
+        trim_mcp: false,
+        model: "opus",
+        effort: "high",
+    },
+    hash: "ccd6829afca0f806e52f010b15a0ae407f58df6465a6edd11c58a6a543e369d8",
+};
+export const PLUGIN_DIR_HASH_VECTOR = {
+    files: [
+        {
+            path: "hooks/x.sh",
+            sha256: "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        },
+        { path: "a.json", sha256: "0000000000000000000000000000000000000000000000000000000000000000" },
+    ],
+    hash: "c9df73b3ae9cd900bb324ee0c5bb3f142a58cf5fac29673a038e95098edab5cd",
+};
+export const CHAIN_ID_VECTOR = {
+    root_prompt_id: "root-prompt-0001",
+    chain_id: "66e05a0707771bf96685f5963062f0c6413ec65c3cc159038aba55b081545100",
+};
+/**
+ * Charter hash chain (C07-R04): a v1 genesis row and a v2 row chained to it, computed with an
+ * independent Python canonical-JSON + hashlib generator (scratchpad s1gen/charter_gen.py). created_at
+ * is given in the row's text form; the preimage carries its canonical form.
+ */
+export const CHARTER_HASH_VECTORS = {
+    "session_id": "11111111-2222-4333-8444-555555555555",
+    "rows": [
+        {
+            "version": 1,
+            "prev_hash": "0000000000000000000000000000000000000000000000000000000000000000",
+            "charter": {
+                "statement_hash": "51d9393d4b1b22b84e4fe45acb3e4f3c561e75d03701771aa40c805a5146f939",
+                "requirements_hash": "566af8b913e8827626360e11b53b0356f9784508e3e51e36c9d6d4ce5b64bb31",
+                "budget_usd": 5,
+                "max_turns": 40,
+                "pins": {
+                    "card_content_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+                    "policy_engine_major": 3
+                },
+                "tool_classes": {
+                    "Bash": "input_dependent"
+                },
+                "launch_spec": {
+                    "v": 1,
+                    "cwd": "/Users/dev/repo",
+                    "plugin": "bundled-mnemom",
+                    "trim_mcp": false,
+                    "model": "opus",
+                    "effort": "high"
+                }
+            },
+            "created_at": "2026-10-16 12:00:00.123+00",
+            "preimage": "{\"charter\":{\"budget_usd\":5,\"launch_spec\":{\"cwd\":\"/Users/dev/repo\",\"effort\":\"high\",\"model\":\"opus\",\"plugin\":\"bundled-mnemom\",\"trim_mcp\":false,\"v\":1},\"max_turns\":40,\"pins\":{\"card_content_hash\":\"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\",\"policy_engine_major\":3},\"requirements_hash\":\"566af8b913e8827626360e11b53b0356f9784508e3e51e36c9d6d4ce5b64bb31\",\"statement_hash\":\"51d9393d4b1b22b84e4fe45acb3e4f3c561e75d03701771aa40c805a5146f939\",\"tool_classes\":{\"Bash\":\"input_dependent\"}},\"created_at\":\"2026-10-16T12:00:00.123000Z\",\"prev_hash\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"session_id\":\"11111111-2222-4333-8444-555555555555\",\"v\":1,\"version\":1}",
+            "hash": "1db9e38158199cec38e592881b9568aa79005c230c28f4fee3cc139ddf676eaf"
+        },
+        {
+            "version": 2,
+            "prev_hash": "1db9e38158199cec38e592881b9568aa79005c230c28f4fee3cc139ddf676eaf",
+            "charter": {
+                "statement_hash": "51d9393d4b1b22b84e4fe45acb3e4f3c561e75d03701771aa40c805a5146f939",
+                "requirements_hash": "566af8b913e8827626360e11b53b0356f9784508e3e51e36c9d6d4ce5b64bb31",
+                "budget_usd": 4,
+                "max_turns": 40,
+                "pins": {
+                    "card_content_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+                    "policy_engine_major": 3
+                },
+                "tool_classes": {
+                    "Bash": "input_dependent"
+                },
+                "launch_spec": {
+                    "v": 1,
+                    "cwd": "/Users/dev/repo",
+                    "plugin": "bundled-mnemom",
+                    "trim_mcp": false,
+                    "model": "opus",
+                    "effort": "high"
+                }
+            },
+            "created_at": "2026-10-16T12:05:00Z",
+            "preimage": "{\"charter\":{\"budget_usd\":4,\"launch_spec\":{\"cwd\":\"/Users/dev/repo\",\"effort\":\"high\",\"model\":\"opus\",\"plugin\":\"bundled-mnemom\",\"trim_mcp\":false,\"v\":1},\"max_turns\":40,\"pins\":{\"card_content_hash\":\"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\",\"policy_engine_major\":3},\"requirements_hash\":\"566af8b913e8827626360e11b53b0356f9784508e3e51e36c9d6d4ce5b64bb31\",\"statement_hash\":\"51d9393d4b1b22b84e4fe45acb3e4f3c561e75d03701771aa40c805a5146f939\",\"tool_classes\":{\"Bash\":\"input_dependent\"}},\"created_at\":\"2026-10-16T12:05:00.000000Z\",\"prev_hash\":\"1db9e38158199cec38e592881b9568aa79005c230c28f4fee3cc139ddf676eaf\",\"session_id\":\"11111111-2222-4333-8444-555555555555\",\"v\":1,\"version\":2}",
+            "hash": "70306a09f19c8df756547dae953756c3151536d30e0d7d46cbc8c4db0252b4c1"
+        }
+    ]
+};
+/**
+ * Amendment 55 seal round trip (C07-R02, R13, R14). `seal` is the contract C07-HDR-01 sealed through a
+ * live gateway, which answered x-mnemom-contract-hash `gateway_enforce_h16` (mode enforce) and, for the
+ * same contract rehydrated as nudge, `gateway_nudge_h16`. The full hashes, the commitments and the v1
+ * charter row are from an independent Python canonical-JSON + hashlib generator (scratchpad
+ * s1gen/seal_gen.py). `sealed_at` is the seal instant in an offset form; charter_v1.created_at is it in UTC.
+ */
+export const SEAL_VECTORS = {
+    "seal": {
+        "statement": "Ship the release. canary zq-k1-102d461d964a345ca757",
+        "requirements": [
+            "Tests stay green. canary zq-k2-54e87989d0dd1c2f7a00"
+        ],
+        "budget_usd": 5,
+        "max_turns": 40,
+        "time_limit_s": 3600,
+        "mode": "enforce",
+        "allowed_paths": [
+            "src/**"
+        ],
+        "forbidden_paths": [
+            "secrets/**"
+        ]
+    },
+    "enforce_hash": "85fc982c26cf4a28ac1e7e3ba0f746a83bd96bc3ce7a3ed84401f79aa684d13a",
+    "gateway_enforce_h16": "85fc982c26cf4a28",
+    "nudge_hash": "d0344555137faf1ce06f81bb905ec9dfb15dd385de57b6a959e381bf1f3fe654",
+    "gateway_nudge_h16": "d0344555137faf1c",
+    "sealed_at": "2026-10-29T12:45:33.355-07:00",
+    "charter_v1": {
+        "commitments": {
+            "statement_hash": "04ed1e6039e500e2a1d09fd4238a77863cdfc699e504cea01a4c63263ffdf538",
+            "requirements_hash": "d594733b87aa9594eb4d084a49e8450aa8ac9e32ffb9c985d7a2f24fa6513fcd",
+            "contract_hash": "85fc982c26cf4a28ac1e7e3ba0f746a83bd96bc3ce7a3ed84401f79aa684d13a",
+            "mode": "enforce",
+            "budget_usd": 5,
+            "max_turns": 40,
+            "active_time_limit_s": 3600,
+            "pins": {
+                "card_content_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+                "policy_engine_major": 3
+            },
+            "tool_classes": {
+                "Bash": "input_dependent"
+            }
+        },
+        "created_at": "2026-10-29T19:45:33.355000Z",
+        "preimage": "{\"charter\":{\"active_time_limit_s\":3600,\"budget_usd\":5,\"contract_hash\":\"85fc982c26cf4a28ac1e7e3ba0f746a83bd96bc3ce7a3ed84401f79aa684d13a\",\"max_turns\":40,\"mode\":\"enforce\",\"pins\":{\"card_content_hash\":\"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\",\"policy_engine_major\":3},\"requirements_hash\":\"d594733b87aa9594eb4d084a49e8450aa8ac9e32ffb9c985d7a2f24fa6513fcd\",\"statement_hash\":\"04ed1e6039e500e2a1d09fd4238a77863cdfc699e504cea01a4c63263ffdf538\",\"tool_classes\":{\"Bash\":\"input_dependent\"}},\"created_at\":\"2026-10-29T19:45:33.355000Z\",\"prev_hash\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"session_id\":\"11111111-2222-4333-8444-555555555555\",\"v\":1,\"version\":1}",
+        "hash": "5a3bb041c155d67e50d18ee9afb0e6903f7a64988c881ab6373d3447fd5906f5"
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.33",
+  "version": "0.17.34-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
     "smoltbot": "./dist/smoltbot-shim.js"
   },
   "scripts": {
-    "build": "node scripts/vendor-durable-contract.mjs && tsc && node scripts/copy-assets.mjs",
+    "build": "node scripts/vendor-durable-contract.mjs && tsc && node scripts/copy-assets.mjs && node scripts/gen-integrity-manifest.mjs",
+    "prepack": "node scripts/gen-integrity-manifest.mjs --shipped",
     "prepublishOnly": "npm run build",
     "dev": "tsx src/index.ts",
     "gen:command-tree": "node scripts/vendor-durable-contract.mjs && tsx scripts/gen-command-tree.mjs",
@@ -17,6 +18,7 @@
     "test": "vitest"
   },
   "dependencies": {
+    "@mnemom/aip-verifier": "https://github.com/mnemom/aip/releases/download/aip-verifier-v0.6.0/mnemom-aip-verifier-0.6.0.tgz",
     "@mnemom/policy-engine": "^0.3.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
@@ -24,7 +26,6 @@
     "smol-toml": "^1.9.0"
   },
   "devDependencies": {
-    "@mnemom/aip-verifier": "https://github.com/mnemom/aip/releases/download/aip-verifier-v0.6.0/mnemom-aip-verifier-0.6.0.tgz",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^4.1.12",

package/plugins/integrity-manifest.json

@@ -0,0 +1,35 @@
+{
+  "recipe_version": 1,
+  "plugin_dir": "plugins/mnemom",
+  "files": [
+    {
+      "path": ".claude-plugin/plugin.json",
+      "sha256": "3f2e41856c19f2d5ef74a18b47d2dd742211a79ee4dbbdb408129fc38d6cd6df"
+    },
+    {
+      "path": ".mcp.json",
+      "sha256": "5ad367ef1aa4ade2de2ff7d3fac90131d9a160c2a16b2a6133e40b7d7be17ac7"
+    },
+    {
+      "path": "hooks/hooks.json",
+      "sha256": "c9fe91672a14aa8fc74d8fe523e412b7fdbe16a281cdc1d3e51b162fef3a7ed3"
+    },
+    {
+      "path": "hooks/register.tsx",
+      "sha256": "98da58c198d4015a5d454110249b1bc5c9fe0a1e2271c310f46c1185935d4436"
+    },
+    {
+      "path": "hooks/seat-hello.mjs",
+      "sha256": "4d6cd4e2fed2dc701bc6990ed5c43b37fb4aaf202b25012c3a052845d624daee"
+    },
+    {
+      "path": "skills/about-mnemom/SKILL.md",
+      "sha256": "30712f4630e769986c17260f6187323b5d0df11623b03dbdeaf7d3a5fb709081"
+    },
+    {
+      "path": "types/index.d.ts",
+      "sha256": "b877ea4d4d6fe11ae2eb10e035b5f017b225905f7f9ec015b3c3010609cad27b"
+    }
+  ],
+  "dir_hash": "ad16249ecbdd1e2fc6913529f9aefb357d516da7230f26a4e1c2c0ccf09735c5"
+}

package/plugins/mnemom/hooks/hooks.json

@@ -1,3 +1,17 @@
 {
-  "modules": ["./register.tsx"]
+  "modules": ["./register.tsx"],
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -z \"$MNEMOM_SEAT_SOCKET\" ] || node \"${CLAUDE_PLUGIN_ROOT}/hooks/seat-hello.mjs\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
 }

package/plugins/mnemom/hooks/register.tsx

@@ -197,6 +197,24 @@ const GOAL_REFRESH_DELAY_MS = 1500;
 /** How long one `mnemom agent … --json` may take before it reads as unavailable. */
 const GOAL_READ_TIMEOUT_MS = 8000;
 
+/**
+ * `/mnemom lock` (durable sessions, BACKBONE C1; S1 PLUGIN_LOCK_ARGV, ruling 33.27.1): typed by the
+ * person, never run by the mod on its own. Offered only when the launcher said the launch is
+ * durable (MNEMOM_CC_DURABLE=1, set only with the `durable` experimental gate on); otherwise
+ * `/mnemom lock` is the plain status, exactly as before.
+ */
+// The env reads below name MNEMOM_CC_DURABLE (the CLI's PLUGIN_DURABLE_ENV) and
+// MNEMOM_AGENT_SESSION_NAME (the env slot of S1 PLUGIN_LOCK_ARGV: the session's name, set by the
+// launcher in the claude it starts) as literals only because `claude plugin validate` requires a
+// literal first argument to $.env.get. claude-plugin.test.ts fails CI if either drifts from its
+// source constant.
+/** The CLI call: `mnemom agent lock <session name>`, no option, cwd inherited (S1 PLUGIN_LOCK_ARGV). */
+function pluginLockArgv(sessionName: string | undefined): string[] | null {
+  return sessionName ? ["agent", "lock", sessionName] : null;
+}
+/** The lock waits for the host daemon's seat (up to ATTACH_WAIT_S) before it answers. */
+const LOCK_TIMEOUT_MS = 300_000;
+
 /**
  * The Trust Rating lookup in flight, if any. Started beside the session start (never in its way),
  * awaited by `/mnemom status` and `/mnemom doctor` so they report a settled rating, and swallowed
@@ -896,6 +914,17 @@ function statusText(
   return lines.join("\n");
 }
 
+const HELP_LOCK =
+  "  /mnemom lock       make this session durable (the host daemon keeps it running)";
+
+function helpText(durable: boolean): string {
+  if (!durable) return HELP;
+  const lines = HELP.split("\n");
+  const at = lines.findIndex((x) => x.startsWith("  /mnemom show"));
+  lines.splice(at + 1, 0, HELP_LOCK);
+  return lines.join("\n");
+}
+
 const HELP = [
   `${SIGN} /mnemom — Mnemom for Claude Code`,
   "",
@@ -935,6 +964,29 @@ async function refreshGoal(
   return g;
 }
 
+/** `/mnemom lock`: run `mnemom agent lock <name>` through the launcher's own argv, show its answer. */
+async function runLock(
+  $: RunDollar & { env: { get: (k: string) => Promise<string | undefined> } },
+  l: MnemomLaunch | null,
+): Promise<string> {
+  // As S1 pluginLockArgv: the value as is; unset or empty runs no CLI call.
+  const argv = pluginLockArgv((await $.env.get("MNEMOM_AGENT_SESSION_NAME")) || undefined);
+  if (l === null || l.launcherExec.length === 0 || argv === null) {
+    return `${SIGN} /mnemom lock — this session was not started by \`mnemom agent <name>\`, so there is nothing to lock from here.`;
+  }
+  try {
+    const res = await $.process.run([...l.launcherExec, ...argv], { timeoutMs: LOCK_TIMEOUT_MS });
+    const said = [res.stdout, res.stderr]
+      .map((x) => x.trim())
+      .filter(Boolean)
+      .join("\n");
+    const head = res.exitCode === 0 ? `${SIGN} /mnemom lock` : `${SIGN} /mnemom lock — not locked`;
+    return said ? `${head}\n${said}` : head;
+  } catch (err) {
+    return `${SIGN} /mnemom lock — could not run mnemom (${err instanceof Error ? err.message : String(err)})`;
+  }
+}
+
 export const register: Register = (on, rawOptions) => {
   const options = readOptions(rawOptions);
   let composeCache: { key: string; text: string } | null = null;
@@ -946,11 +998,14 @@ export const register: Register = (on, rawOptions) => {
     await update($, reputation, () => (l ? { state: "loading" } : null));
     await update($, goal, () => (l && l.goalMode !== "off" ? { state: "loading" } : null));
 
+    const durable = (await $.env.get("MNEMOM_CC_DURABLE")) === "1";
     await $.command.register({
       name: "mnemom",
       description:
         "Mnemom governance: status, the goal, status pane, doctor, verify, hide/show the band",
-      argumentHint: "[status|goal|panel|close|doctor|verify|hide|show|help]",
+      argumentHint: durable
+        ? "[status|goal|panel|close|doctor|verify|hide|show|lock|help]"
+        : "[status|goal|panel|close|doctor|verify|hide|show|help]",
       immediate: true,
     });
 
@@ -997,7 +1052,10 @@ export const register: Register = (on, rawOptions) => {
     const l = await read($, launch);
     const verb = (e.args ?? "").trim().split(/\s+/)[0]?.toLowerCase() ?? "";
 
-    if (verb === "help" || verb === "-h" || verb === "--help") return { text: HELP };
+    const durable = (await $.env.get("MNEMOM_CC_DURABLE")) === "1";
+    if (verb === "help" || verb === "-h" || verb === "--help") return { text: helpText(durable) };
+
+    if (verb === "lock" && durable) return { text: await runLock($, l) };
 
     if (verb === "goal" || verb === "contract") {
       if (l === null) return { text: statusText(null, null, null, await read($, turns), 0) };

package/plugins/mnemom/hooks/seat-hello.mjs

@@ -0,0 +1,116 @@
+// The seat hello (BACKBONE C2 item 15; ruling B-hellohook; dogfood B2): a COMMAND hook on
+// SessionStart, so it runs whether or not the engine loads hooks modules (register.tsx needs
+// CLAUDE_CODE_ENABLE_FUNCTION_HOOKS; this does not).
+//
+// In a durable seat the seat launcher puts MNEMOM_SEAT_SOCKET (the seat proxy's per-seat 0600
+// socket) and the seat's session, spawn and epoch ids in claude's env. This sends the one hello
+// that socket serves, `{op:"hello", session_id, spawn_id, epoch}` as one JSON line, and reads its
+// one-line answer (cli/src/durable/seat-socket.ts). Without MNEMOM_SEAT_SOCKET (every launch that
+// is not a durable seat) it does nothing. It never sees a key: the ids are non-secret, and the
+// seat proxy relays the hello to the daemon, which holds the executor key.
+//
+// It never fails the session: it always exits 0 and writes nothing to stdout (a SessionStart
+// hook's stdout becomes model context). A refused or failed hello is one stderr line.
+import net from "node:net";
+import { pathToFileURL } from "node:url";
+
+export const SEAT_SOCKET_ENV = "MNEMOM_SEAT_SOCKET";
+export const SEAT_SESSION_ENV = "MNEMOM_SEAT_SESSION_ID";
+export const SEAT_SPAWN_ENV = "MNEMOM_SEAT_SPAWN_ID";
+export const SEAT_EPOCH_ENV = "MNEMOM_SEAT_EPOCH";
+
+/** The seat socket answers within the daemon's API round trip; the hook's own timeout is 30 s. */
+export const HELLO_TIMEOUT_MS = 20_000;
+
+/**
+ * What to send, from the env: `{ skip: true }` outside a seat, `{ error }` when the seat env is
+ * incomplete, else the socket path and the hello frame. The epoch goes as a number (the seat
+ * socket compares it strictly).
+ */
+export function helloFromEnv(env) {
+  const socketPath = env[SEAT_SOCKET_ENV];
+  if (!socketPath) return { skip: true };
+  const sessionId = env[SEAT_SESSION_ENV];
+  const spawnId = env[SEAT_SPAWN_ENV];
+  const epoch = env[SEAT_EPOCH_ENV];
+  if (!sessionId || !spawnId) return { error: "the seat env has no session or spawn id" };
+  if (!/^\d{1,9}$/.test(epoch ?? "")) return { error: "the seat env has no valid epoch" };
+  return {
+    socketPath,
+    frame: { op: "hello", session_id: sessionId, spawn_id: spawnId, epoch: Number(epoch) },
+  };
+}
+
+/** The seat socket's answer is one short JSON line; a longer one without a newline is not it. */
+export const MAX_ANSWER_BYTES = 4096;
+
+/** One JSON line out, the first line back. Rejects on a socket error, a reply-less close or the timeout. */
+export function sendHello(socketPath, frame, timeoutMs = HELLO_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const sock = net.createConnection({ path: socketPath });
+    let buf = "";
+    const timer = setTimeout(() => {
+      sock.destroy();
+      reject(new Error("no answer in time"));
+    }, timeoutMs);
+    sock.on("connect", () => sock.write(`${JSON.stringify(frame)}\n`));
+    sock.on("data", (d) => {
+      buf += d.toString("utf8");
+      const i = buf.indexOf("\n");
+      if (i < 0 && buf.length > MAX_ANSWER_BYTES) {
+        clearTimeout(timer);
+        sock.destroy();
+        reject(new Error("answer too long"));
+      } else if (i >= 0) {
+        clearTimeout(timer);
+        sock.end();
+        resolve(buf.slice(0, i));
+      }
+    });
+    sock.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    sock.on("close", () => {
+      clearTimeout(timer);
+      if (buf.indexOf("\n") < 0) reject(new Error("closed without an answer"));
+    });
+  });
+}
+
+/** Whether the answer line is an accepted hello (`{"ok":true,...}`). */
+export function accepted(line) {
+  try {
+    const v = JSON.parse(line);
+    return Boolean(v) && typeof v === "object" && v.ok === true;
+  } catch {
+    return false;
+  }
+}
+
+/** The hook: resolves to what it did ("skipped" | "accepted" | "refused" | "failed"). Never throws. */
+export async function runSeatHello(env, deps = {}) {
+  const send = deps.send ?? sendHello;
+  const warn = deps.warn ?? ((l) => process.stderr.write(`${l}\n`));
+  const h = helloFromEnv(env);
+  if (h.skip) return "skipped";
+  if (h.error) {
+    warn(`mnemom: seat hello not sent: ${h.error}`);
+    return "failed";
+  }
+  let line;
+  try {
+    line = await send(h.socketPath, h.frame);
+  } catch (e) {
+    warn(`mnemom: seat hello failed: ${e instanceof Error ? e.message : String(e)}`);
+    return "failed";
+  }
+  if (accepted(line)) return "accepted";
+  warn(`mnemom: seat hello refused: ${line}`);
+  return "refused";
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await runSeatHello(process.env);
+  process.exitCode = 0;
+}

package/dist/commands/agent-implicit-notice.d.ts

@@ -1,31 +0,0 @@
-/**
- * The one-time notice for door one's T16 default (decisions 12 and 22, OD-13): on a
- * prerelease (`next`) build an interactive or Remote Control launch with nothing
- * configured runs with an implicit goal. The first launch that gets that default says
- * so once, with both opt-outs; every later launch is silent.
- *
- * State file (~/.mnemom/implicit-notice.json): { shown_at }. A launch with an explicit
- * mode (a flag, `--goal`, `goal_mode`, the experimental feature) never reaches this, and
- * --dry-run neither prints nor records it. A state file that cannot be read counts as
- * not shown; one that cannot be written never fails the launch.
- */
-export declare const IMPLICIT_NOTICE_FILE = "implicit-notice.json";
-export declare const IMPLICIT_DEFAULT_NOTICE: string;
-export interface ImplicitNoticeDeps {
-    /** The state file's text, or null when it is missing or unreadable. */
-    read(): string | null;
-    write(text: string): void;
-    note(line: string): void;
-    now(): Date;
-}
-/** Has the notice been shown on this machine? Any parseable `shown_at` string counts. */
-export declare function noticeShown(text: string | null): boolean;
-/** Print the notice unless it was shown before, then record it. Returns whether it printed. */
-export declare function maybeShowImplicitNotice(opts: {
-    dryRun?: boolean;
-}, deps: ImplicitNoticeDeps): boolean;
-export declare function defaultImplicitNoticeDeps(mnemomDir?: string): ImplicitNoticeDeps;
-/** Called by the launch when its implicit goal came from the prerelease default. */
-export declare function showImplicitDefaultNoticeOnce(opts: {
-    dryRun?: boolean;
-}, deps?: ImplicitNoticeDeps): boolean;

package/dist/commands/agent-implicit-notice.js

@@ -1,73 +0,0 @@
-/**
- * The one-time notice for door one's T16 default (decisions 12 and 22, OD-13): on a
- * prerelease (`next`) build an interactive or Remote Control launch with nothing
- * configured runs with an implicit goal. The first launch that gets that default says
- * so once, with both opt-outs; every later launch is silent.
- *
- * State file (~/.mnemom/implicit-notice.json): { shown_at }. A launch with an explicit
- * mode (a flag, `--goal`, `goal_mode`, the experimental feature) never reaches this, and
- * --dry-run neither prints nor records it. A state file that cannot be read counts as
- * not shown; one that cannot be written never fails the launch.
- */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { MNEMOM_DIR } from "../lib/config.js";
-export const IMPLICIT_NOTICE_FILE = "implicit-notice.json";
-export const IMPLICIT_DEFAULT_NOTICE = "mnemom: implicit goals are on by default in this prerelease. The gateway infers the " +
-    "session's goal from your messages, and the record says the goal was implicit, never sealed. " +
-    "Turn it off for one launch with --no-implicit, or for every launch with " +
-    "`mnemom agent config set goal_mode off`.";
-/** Has the notice been shown on this machine? Any parseable `shown_at` string counts. */
-export function noticeShown(text) {
-    if (text === null)
-        return false;
-    try {
-        const v = JSON.parse(text);
-        return (typeof v === "object" &&
-            v !== null &&
-            typeof v.shown_at === "string");
-    }
-    catch {
-        return false;
-    }
-}
-/** Print the notice unless it was shown before, then record it. Returns whether it printed. */
-export function maybeShowImplicitNotice(opts, deps) {
-    if (opts.dryRun)
-        return false;
-    if (noticeShown(deps.read()))
-        return false;
-    deps.note(IMPLICIT_DEFAULT_NOTICE);
-    try {
-        deps.write(`${JSON.stringify({ shown_at: deps.now().toISOString() })}\n`);
-    }
-    catch {
-        // Never fail a launch over a notice.
-    }
-    return true;
-}
-export function defaultImplicitNoticeDeps(mnemomDir = MNEMOM_DIR) {
-    const path = join(mnemomDir, IMPLICIT_NOTICE_FILE);
-    return {
-        read: () => {
-            try {
-                return readFileSync(path, "utf8");
-            }
-            catch {
-                return null;
-            }
-        },
-        write: (text) => {
-            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-            const tmp = `${path}.${process.pid}.tmp`;
-            writeFileSync(tmp, text, { mode: 0o600 });
-            renameSync(tmp, path);
-        },
-        note: (line) => console.error(line),
-        now: () => new Date(),
-    };
-}
-/** Called by the launch when its implicit goal came from the prerelease default. */
-export function showImplicitDefaultNoticeOnce(opts, deps = defaultImplicitNoticeDeps()) {
-    return maybeShowImplicitNotice(opts, deps);
-}