@wipcomputer/wip-ldm-os 0.4.85-alpha.9 → 0.4.86

package/scripts/test-boot-hook-registration.mjs

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+// Regression test: configureSessionStartHook() registration semantics.
+//
+// Covers the 2026-07-04 tickets:
+//   ai/product/bugs/installer/open-tickets/2026-07-04--cc-mini--boot-hook-update-in-place-never-persists.md
+//   ai/product/bugs/installer/open-tickets/2026-07-04--cc-mini--installer-sessionstart-hook-duplicate-registration.md
+//
+// Cases:
+//   1. Fresh install: entry added and persisted.
+//   2. Repeat run: no duplicate, file byte-identical (no write).
+//   3. Changed entry (old command path, old timeout): updated ON DISK.
+//      This is the update-in-place-never-persists bug.
+//   4. Duplicate-laden settings (10 boot-hook copies + 1 unrelated hook):
+//      collapses to 1 boot entry, unrelated hook preserved, persisted.
+
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Note: the temp prefix must not contain "boot-hook" or "shared/boot".
+// Those substrings are the installer's ownership matchers, and the temp
+// HOME path ends up inside every fixture hook command.
+const tempHome = mkdtempSync(join(tmpdir(), 'ldm-bootreg-'));
+
+let failed = 0;
+function assert(cond, label, detail = '') {
+  if (cond) {
+    console.log(`  [PASS] ${label}`);
+  } else {
+    console.log(`  [FAIL] ${label}`);
+    if (detail) console.log(`         ${detail}`);
+    failed++;
+  }
+}
+
+const settingsPath = join(tempHome, '.claude', 'settings.json');
+function seedSettings(obj) {
+  mkdirSync(join(tempHome, '.claude'), { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(obj, null, 2) + '\n');
+}
+function readSettings() {
+  return JSON.parse(readFileSync(settingsPath, 'utf-8'));
+}
+function bootEntries(settings) {
+  return (settings.hooks?.SessionStart || []).filter((entry) =>
+    (entry?.hooks || []).some((h) => h?.command?.includes('boot-hook'))
+  );
+}
+
+try {
+  // HOME must be set before the module import: installer.mjs resolves
+  // homedir() into module-level constants at import time.
+  process.env.HOME = tempHome;
+  const { configureSessionStartHook } = await import('../src/boot/installer.mjs');
+  const expectedCommand = `node ${join(tempHome, '.ldm', 'shared', 'boot', 'boot-hook.mjs')}`;
+
+  console.log('Test 1: fresh install adds and persists the entry');
+  {
+    seedSettings({ hooks: {} });
+    const msg = configureSessionStartHook();
+    const s = readSettings();
+    assert(/added/.test(msg), `reports added (got: ${msg})`);
+    assert(bootEntries(s).length === 1, 'exactly one boot-hook entry on disk');
+    assert(s.hooks.SessionStart[0].hooks[0].command === expectedCommand, 'command path is BOOT_DIR boot-hook.mjs');
+  }
+
+  console.log('Test 2: repeat run is a no-op, byte-identical file');
+  {
+    const before = readFileSync(settingsPath, 'utf-8');
+    const msg = configureSessionStartHook();
+    const after = readFileSync(settingsPath, 'utf-8');
+    assert(/already configured/.test(msg), `reports already configured (got: ${msg})`);
+    assert(before === after, 'settings.json byte-identical after second run');
+  }
+
+  console.log('Test 3: changed entry is updated ON DISK (the persist bug)');
+  {
+    seedSettings({
+      hooks: {
+        SessionStart: [
+          {
+            matcher: '*',
+            hooks: [{ type: 'command', command: 'node /old/path/shared/boot/boot-hook.mjs', timeout: 10 }],
+          },
+        ],
+      },
+    });
+    const msg = configureSessionStartHook();
+    const s = readSettings();
+    assert(/updated/.test(msg), `reports updated (got: ${msg})`);
+    assert(bootEntries(s).length === 1, 'still exactly one boot-hook entry');
+    assert(
+      s.hooks.SessionStart[0].hooks[0].command === expectedCommand,
+      'new command path persisted to disk',
+      `on disk: ${s.hooks.SessionStart[0].hooks[0].command}`
+    );
+    assert(s.hooks.SessionStart[0].hooks[0].timeout === 15, 'new timeout persisted to disk');
+  }
+
+  console.log('Test 4: duplicate-laden settings collapse to one, unrelated hooks preserved');
+  {
+    const bootEntry = {
+      matcher: '*',
+      hooks: [{ type: 'command', command: expectedCommand, timeout: 15 }],
+    };
+    const guardEntry = {
+      hooks: [{ type: 'command', command: `node ${join(tempHome, '.ldm', 'extensions', 'wip-branch-guard', 'guard.mjs')}`, timeout: 10 }],
+    };
+    seedSettings({
+      hooks: {
+        SessionStart: [
+          ...Array.from({ length: 5 }, () => structuredClone(bootEntry)),
+          guardEntry,
+          ...Array.from({ length: 5 }, () => structuredClone(bootEntry)),
+        ],
+      },
+    });
+    const msg = configureSessionStartHook();
+    const s = readSettings();
+    assert(/removed 9 duplicate entries/.test(msg), `reports 9 duplicates removed (got: ${msg})`);
+    assert(bootEntries(s).length === 1, 'exactly one boot-hook entry after collapse');
+    assert(s.hooks.SessionStart.length === 2, 'boot hook + branch guard remain');
+    assert(
+      s.hooks.SessionStart.some((e) => e.hooks?.[0]?.command?.includes('wip-branch-guard')),
+      'unrelated branch-guard entry preserved'
+    );
+  }
+} finally {
+  rmSync(tempHome, { recursive: true, force: true });
+}
+
+if (failed > 0) {
+  console.log(`\n${failed} assertion(s) failed`);
+  process.exit(1);
+}
+console.log('\nAll boot-hook registration tests passed');

package/scripts/test-boot-payload-trim.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// Regression test: boot-hook payload trimming (CC speedup master plan, Task 4b).
+//
+// Covers:
+//   1. A step with no maxLines in config gets the code default cap + a
+//      truncation marker that names the full path.
+//   2. A per-step maxLines in config overrides the default.
+//   3. A most-recent step whose newest file is older than stalenessDays is
+//      NOT injected: a path-only stale line is emitted instead.
+//   4. A fresh most-recent file IS injected in full.
+//   5. The payload ends with a one-line summary (bytes/lines/sections, capped,
+//      stale).
+//   6. maxTotalLines still stops the loop early.
+//
+// The hook resolves homedir() into a module-level constant at import time and
+// loads boot-config.json relative to its own file. So each case copies the
+// hook into a temp workdir next to a generated boot-config.json and runs it as
+// a subprocess with HOME pointed at a temp fixture. The hook's dynamic imports
+// of ../../lib/*.mjs fail harmlessly (they are wrapped in try/catch) from the
+// temp location, which is fine: this test only exercises payload assembly.
+
+import { mkdirSync, mkdtempSync, copyFileSync, writeFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const repo = dirname(dirname(fileURLToPath(import.meta.url)));
+const HOOK_SRC = join(repo, 'src', 'boot', 'boot-hook.mjs');
+
+let failed = 0;
+function assert(cond, label, detail = '') {
+  if (cond) {
+    console.log(`  [PASS] ${label}`);
+  } else {
+    console.log(`  [FAIL] ${label}`);
+    if (detail) console.log(`         ${detail}`);
+    failed++;
+  }
+}
+
+// Compute today/yesterday in the hook's timezone so daily-log and fresh-journal
+// filenames match what the hook looks for.
+function ymd(offsetDays = 0) {
+  const now = new Date();
+  now.setDate(now.getDate() + offsetDays);
+  return new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'America/Los_Angeles',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).format(now);
+}
+
+function lines(n, marker) {
+  const out = [];
+  for (let i = 1; i <= n; i++) out.push(`${marker} line ${i}`);
+  return out.join('\n') + '\n';
+}
+
+// Run the hook with a given config object and a HOME-populating callback.
+// Returns the injected additionalContext string.
+function runHook(configObj, populateHome) {
+  const work = mkdtempSync(join(tmpdir(), 'ldm-bootpay-work-'));
+  const home = mkdtempSync(join(tmpdir(), 'ldm-bootpay-home-'));
+  try {
+    copyFileSync(HOOK_SRC, join(work, 'boot-hook.mjs'));
+    writeFileSync(join(work, 'boot-config.json'), JSON.stringify(configObj, null, 2));
+    populateHome(home);
+
+    const stdout = execFileSync('node', [join(work, 'boot-hook.mjs')], {
+      input: JSON.stringify({ session_id: 'test', hook_event_name: 'SessionStart', cwd: home }),
+      env: { ...process.env, HOME: home },
+      encoding: 'utf-8',
+      timeout: 30000,
+    });
+    const parsed = JSON.parse(stdout);
+    return parsed?.hookSpecificOutput?.additionalContext || '';
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+function writeHomeFile(home, rel, content) {
+  const full = join(home, rel);
+  mkdirSync(dirname(full), { recursive: true });
+  writeFileSync(full, content);
+  return full;
+}
+
+// ── Case 1 + 2 + 5: default cap, config override, payload summary ──
+console.log('Case 1/2/5: default cap, config override, payload summary');
+{
+  const config = {
+    agentId: 'test-agent',
+    timezone: 'America/Los_Angeles',
+    maxTotalLines: 2000,
+    steps: {
+      // no maxLines -> code default for sharedContext is 80
+      sharedContext: { path: '~/shared.md', label: 'SHARED', stepNumber: 2, critical: true },
+      // no maxLines -> code default for soul is 80
+      soul: { path: '~/soul.md', label: 'SOUL', stepNumber: 7 },
+      // explicit maxLines overrides
+      overridden: { path: '~/capped.md', label: 'CAPPED', stepNumber: 11, maxLines: 5 },
+    },
+  };
+  let soulPath, cappedPath;
+  const ctx = runHook(config, (home) => {
+    writeHomeFile(home, 'shared.md', lines(20, 'SHARED_BODY')); // under cap, not truncated
+    soulPath = writeHomeFile(home, 'soul.md', lines(200, 'SOUL_BODY')); // over default 80
+    cappedPath = writeHomeFile(home, 'capped.md', lines(100, 'CAP_BODY')); // over explicit 5
+  });
+
+  assert(/truncated at 80 of \d+ lines/.test(ctx), 'soul truncated at default cap 80', ctx.match(/truncated at[^\n]*soul[^\n]*/)?.[0] || ctx.slice(0, 300));
+  assert(ctx.includes(`Read the rest: ${soulPath}`), 'soul truncation marker names full path');
+  assert(/truncated at 5 of \d+ lines/.test(ctx), 'config maxLines=5 override respected');
+  assert(ctx.includes(`Read the rest: ${cappedPath}`), 'capped truncation marker names full path');
+  assert(/SHARED_BODY line 20\b/.test(ctx), 'under-cap file not truncated (body fully present)');
+  const summaryLine = ctx.match(/== Boot payload:[^\n]*/)?.[0] || '';
+  assert(/== Boot payload: \d+ bytes, \d+ lines, \d+ sections\./.test(summaryLine), 'payload summary line present', summaryLine);
+  const cappedPart = summaryLine.match(/Capped:([^.]*)\./)?.[1] || '';
+  assert(/Step 7\b/.test(cappedPart) && /Step 11\b/.test(cappedPart), 'summary lists capped steps 7 and 11', summaryLine);
+  assert(/Stale\/path-only: none\./.test(summaryLine), 'summary reports no stale steps', summaryLine);
+}
+
+// ── Case 3: stale most-recent journal emits path-only line ──
+console.log('Case 3: stale journal is path-only, body not injected');
+{
+  const config = {
+    agentId: 'test-agent',
+    timezone: 'America/Los_Angeles',
+    maxTotalLines: 2000,
+    stalenessDays: 14,
+    steps: {
+      ccJournals: { dir: '~/journals', label: 'JOURNAL', stepNumber: 8, maxLines: 80, strategy: 'most-recent' },
+    },
+  };
+  const staleDate = ymd(-100);
+  let journalPath;
+  const ctx = runHook(config, (home) => {
+    journalPath = writeHomeFile(home, `journals/${staleDate}-journal.md`, lines(50, 'STALE_JOURNAL_BODY'));
+  });
+
+  assert(!/STALE_JOURNAL_BODY/.test(ctx), 'stale journal body is NOT injected');
+  assert(new RegExp(`stale: newest file is ${staleDate}`).test(ctx), 'stale line names the file date');
+  assert(/cutoff 14d/.test(ctx), 'stale line names the cutoff');
+  assert(ctx.includes(`Read if needed: ${journalPath}`), 'stale line names the full path');
+  assert(/Stale\/path-only: Step 8\b/.test(ctx), 'summary lists stale step 8');
+}
+
+// ── Case 4: fresh most-recent journal is injected in full ──
+console.log('Case 4: fresh journal body IS injected');
+{
+  const config = {
+    agentId: 'test-agent',
+    timezone: 'America/Los_Angeles',
+    maxTotalLines: 2000,
+    stalenessDays: 14,
+    steps: {
+      ccJournals: { dir: '~/journals', label: 'JOURNAL', stepNumber: 8, maxLines: 80, strategy: 'most-recent' },
+    },
+  };
+  const freshDate = ymd(0);
+  const ctx = runHook(config, (home) => {
+    writeHomeFile(home, `journals/${freshDate}-journal.md`, lines(10, 'FRESH_JOURNAL_BODY'));
+  });
+
+  assert(/FRESH_JOURNAL_BODY line 1\b/.test(ctx), 'fresh journal body injected');
+  assert(!/stale:/.test(ctx), 'no stale marker for fresh journal');
+  assert(/Stale\/path-only: none\./.test(ctx), 'summary reports no stale steps');
+}
+
+// ── Case 6: maxTotalLines stops the loop early ──
+console.log('Case 6: maxTotalLines respected');
+{
+  const config = {
+    agentId: 'test-agent',
+    timezone: 'America/Los_Angeles',
+    maxTotalLines: 5, // tiny: first big step blows past it
+    steps: {
+      sharedContext: { path: '~/shared.md', label: 'SHARED', stepNumber: 2, critical: true },
+      context: { path: '~/context.md', label: 'CONTEXT', stepNumber: 6, critical: true },
+    },
+  };
+  const ctx = runHook(config, (home) => {
+    writeHomeFile(home, 'shared.md', lines(40, 'FIRST_BODY'));
+    writeHomeFile(home, 'context.md', lines(40, 'SECOND_BODY'));
+  });
+
+  assert(/FIRST_BODY line 1\b/.test(ctx), 'first step loaded');
+  assert(!/SECOND_BODY/.test(ctx), 'second step skipped after maxTotalLines cap');
+}
+
+console.log('');
+if (failed > 0) {
+  console.log(`${failed} test(s) failed.`);
+  process.exit(1);
+}
+console.log('All boot payload trim tests passed.');

package/scripts/test-crc-agentid-tenant-boundary.mjs

@@ -29,11 +29,11 @@ assertContains("await saveApiKey(apiKey, agentId, { handle: credentialLabel });"
 assertContains("p.handle = identity.handle;", "pair stores display handle separately");
 assertContains("handle: identity.handle,", "relay metadata returns display handle");
 assertContains("codexDaemons.has(identity.agentId)", "daemon presence uses tenant id");
-assertContains("codexDaemonPubkeys.get(identity.agentId)", "daemon pubkey uses tenant id");
+assertContains("codexDaemonPubkeyRegistry.get(identity.agentId)", "daemon pubkey uses tenant id");
 assertContains("agentId: identity.agentId,", "relay tickets bind tenant id");
 assertContains("handle: identity.handle,", "relay tickets preserve display handle");
 assertContains("codexDaemons.set(identity.agentId, ws);", "daemon ws keyed by tenant id");
-assertContains("const key = codexRelayKey(identity.agentId, threadId);", "web ws keyed by tenant id");
+assertContains("const webKey = codexRelayKey(identity.agentId, threadId);", "web ws keyed by tenant id");
 assertContains("const daemonWs = codexDaemons.get(identity.agentId);", "web sends to tenant daemon");
 assertNotContains("const agentId = stored.username || (\"passkey-\"", "registration must not use chosen handle as tenant");
 assertNotContains("const existingKey = Object.entries(API_KEYS).find(([k, v]) => v === agentId);", "oauth must not reuse chosen handle as tenant");

package/scripts/test-crc-e2ee-key-persistence.mjs

@@ -0,0 +1,150 @@
+import { readFileSync } from "node:fs";
+import {
+  buildCodexBootstrapPayload,
+  createCodexDaemonPubkeyRegistry,
+} from "../src/hosted-mcp/codex-relay-e2ee-registry.mjs";
+
+const server = readFileSync("src/hosted-mcp/server.mjs", "utf8");
+const registrySource = readFileSync("src/hosted-mcp/codex-relay-e2ee-registry.mjs", "utf8");
+const deployScript = readFileSync("src/hosted-mcp/deploy.sh", "utf8");
+
+function assertContains(haystack, needle, label) {
+  if (!haystack.includes(needle)) {
+    throw new Error(`${label} missing expected text: ${needle}`);
+  }
+}
+
+function assertBefore(haystack, first, second, label) {
+  const firstIndex = haystack.indexOf(first);
+  const secondIndex = haystack.indexOf(second);
+  if (firstIndex === -1 || secondIndex === -1 || firstIndex >= secondIndex) {
+    throw new Error(`${label} expected "${first}" before "${second}"`);
+  }
+}
+
+function assert(condition, label, detail = "") {
+  if (!condition) throw new Error(`${label}${detail ? ": " + detail : ""}`);
+}
+
+function bootstrapPayloadFor(registry, identity, threadId, daemonOnline = true) {
+  return buildCodexBootstrapPayload({
+    identity,
+    threadId,
+    daemonOnline,
+    daemonKey: registry.get(identity.agentId),
+  });
+}
+
+function createFakePrisma() {
+  const rows = new Map();
+  return {
+    rows,
+    async $executeRawUnsafe(sql, tenantId, pubkey, cryptoVersionsJson) {
+      if (/CREATE TABLE IF NOT EXISTS codex_daemon_e2ee_keys/.test(sql)) return;
+      if (/CREATE TABLE IF NOT EXISTS codex_daemon_e2ee_key_audit/.test(sql)) return;
+      if (/INSERT INTO codex_daemon_e2ee_keys/.test(sql)) {
+        rows.set(tenantId, {
+          tenant_id: tenantId,
+          pubkey,
+          crypto_versions_json: cryptoVersionsJson,
+          registered_at: new Date("2026-05-11T17:37:18.000Z"),
+        });
+        return;
+      }
+      if (/INSERT INTO codex_daemon_e2ee_key_audit/.test(sql)) return;
+      throw new Error("unexpected fake prisma execute: " + sql);
+    },
+    async $queryRawUnsafe(sql) {
+      if (/FROM codex_daemon_e2ee_keys/.test(sql)) return [...rows.values()];
+      throw new Error("unexpected fake prisma query: " + sql);
+    },
+  };
+}
+
+function createSilentLogger() {
+  return { log() {}, error() {} };
+}
+
+assertContains(registrySource, "CREATE TABLE IF NOT EXISTS codex_daemon_e2ee_keys", "persistent key table");
+assertContains(registrySource, "async function loadFromDb()", "boot load helper");
+assertContains(registrySource, "async function persist(agentId, pubkey, cryptoVersions)", "persist helper");
+assertContains(registrySource, "function register(agentId, pubkey, cryptoVersions, source)", "registration helper");
+assertContains(registrySource, "pubkeys.set(agentId, {", "registration updates in-memory bootstrap cache");
+assertContains(registrySource, "return persist(agentId, pubkey, normalizedVersions)", "registration persists after cache update");
+assertContains(server, "await codexDaemonPubkeyRegistry.loadFromDb();", "server boot load call");
+assertContains(server, "await codexDaemonPubkeyRegistry.register(identity.agentId, p.daemon_public_key, p.crypto_versions, \"pair-complete\");", "pair-complete persists key");
+assertContains(server, "if (envelope?.type === \"daemon.identity\") {", "daemon reconnect identity frame");
+assertContains(server, "codexDaemonPubkeyRegistry.register(", "daemon reconnect register call");
+assertContains(server, "buildCodexBootstrapPayload({ identity, threadId, daemonOnline, daemonKey })", "bootstrap uses shared payload builder");
+assertContains(deployScript, "codex-relay-e2ee-registry.mjs", "hosted deploy copies registry module");
+assertBefore(
+  server,
+  "await codexDaemonPubkeyRegistry.loadFromDb();",
+  "function handleCodexBootstrap(req, res, threadId)",
+  "persisted keys load before bootstrap handler",
+);
+
+const identity = {
+  agentId: "acct:test-user-a",
+  tenantId: "acct:test-user-a",
+  handle: "Parker smoke test",
+  apiKey: "ck-test",
+};
+const threadId = "019dfa1e-0c3d-7f01-86b9-9a22cd452bde";
+
+const fakePrisma = createFakePrisma();
+const registryBeforeRestart = createCodexDaemonPubkeyRegistry({
+  usePrisma: true,
+  prisma: fakePrisma,
+  devMode: false,
+  logger: createSilentLogger(),
+});
+await registryBeforeRestart.register(identity.agentId, "spki-key-before-restart", ["e2ee-v1"], "pair-complete");
+
+const beforeRestartBootstrap = bootstrapPayloadFor(registryBeforeRestart, identity, threadId);
+assert(beforeRestartBootstrap.e2ee_available === true, "bootstrap reports e2ee before restart");
+assert(beforeRestartBootstrap.daemon_public_key === "spki-key-before-restart", "bootstrap returns registered daemon key before restart");
+
+const registryAfterRestart = createCodexDaemonPubkeyRegistry({
+  usePrisma: true,
+  prisma: fakePrisma,
+  devMode: false,
+  logger: createSilentLogger(),
+});
+await registryAfterRestart.loadFromDb();
+
+const afterRestartBootstrap = bootstrapPayloadFor(registryAfterRestart, identity, threadId);
+assert(afterRestartBootstrap.e2ee_available === true, "bootstrap reports e2ee after restart from persisted key");
+assert(afterRestartBootstrap.daemon_public_key === "spki-key-before-restart", "bootstrap restores persisted daemon key after restart");
+assert(afterRestartBootstrap.daemon_crypto_versions?.[0] === "e2ee-v1", "bootstrap restores crypto versions after restart");
+
+const emptyFakePrisma = createFakePrisma();
+const registryBeforeReconnect = createCodexDaemonPubkeyRegistry({
+  usePrisma: true,
+  prisma: emptyFakePrisma,
+  devMode: false,
+  logger: createSilentLogger(),
+});
+await registryBeforeReconnect.loadFromDb();
+const beforeReconnectBootstrap = bootstrapPayloadFor(registryBeforeReconnect, identity, threadId);
+assert(beforeReconnectBootstrap.e2ee_available === false, "bootstrap is not e2ee available before daemon reconnect when no key exists");
+assert(beforeReconnectBootstrap.daemon_public_key === null, "bootstrap has no daemon key before daemon reconnect");
+
+await registryBeforeReconnect.register(identity.agentId, "spki-key-from-daemon-reconnect", [], "daemon-reconnect");
+const afterReconnectBootstrap = bootstrapPayloadFor(registryBeforeReconnect, identity, threadId);
+assert(afterReconnectBootstrap.e2ee_available === true, "bootstrap reports e2ee after daemon reconnect self-heal");
+assert(afterReconnectBootstrap.daemon_public_key === "spki-key-from-daemon-reconnect", "bootstrap returns daemon reconnect key");
+assert(afterReconnectBootstrap.daemon_crypto_versions?.[0] === "e2ee-v1", "daemon reconnect defaults crypto version");
+
+const registryAfterReconnectRestart = createCodexDaemonPubkeyRegistry({
+  usePrisma: true,
+  prisma: emptyFakePrisma,
+  devMode: false,
+  logger: createSilentLogger(),
+});
+await registryAfterReconnectRestart.loadFromDb();
+const afterReconnectRestartBootstrap = bootstrapPayloadFor(registryAfterReconnectRestart, identity, threadId);
+assert(afterReconnectRestartBootstrap.e2ee_available === true, "daemon reconnect key is persisted for the next restart");
+assert(afterReconnectRestartBootstrap.daemon_public_key === "spki-key-from-daemon-reconnect", "daemon reconnect key survives restart");
+
+console.log("crc e2ee key persistence restart regression checks passed");

package/scripts/test-crc-e2ee-session-route.mjs

@@ -30,11 +30,18 @@ assertContains("return openCodexWebClientsForKey(codexRelayKey(agentId, routeId)
 assertContains("const targets = resolveCodexWebClientsForDaemonFrame(identity.agentId, sessionId);", "daemon frames use route resolver");
 assertContains("for (const target of targets) {", "daemon frames send to every resolved target");
 assertContains("if (isCodexE2eeEnvelope(envelope) && envelope.session) {", "web e2ee messages are detected");
+assertContains("envelope.route_thread_id = threadId;", "relay injects ticket-bound thread into e2ee hello");
+assertContains("text = JSON.stringify(envelope);", "relay forwards the route-bound e2ee hello");
 assertContains("registerCodexE2eeSessionRoute(identity.agentId, envelope.session, threadId, ws);", "web e2ee session is registered");
-assertContains("const clientCount = addCodexWebClient(key, ws);", "new web connections are added without replacing existing clients");
-assertContains("removeCodexWebClient(key, ws);", "close cleanup removes only the closing socket");
+assertContains("const clientCount = addCodexWebClient(webKey, ws);", "new web connections are added without replacing existing clients");
+assertContains("removeCodexWebClient(webKey, ws);", "close cleanup removes only the closing socket");
 assertContains("removeCodexE2eeRoutesForWeb(identity.agentId, threadId, ws);", "close cleanup");
 assertContains("if (route.webKey === webKey && (!ws || route.ws === ws)) {", "cleanup only removes routes owned by the closing socket");
+assertBefore(
+  "envelope.route_thread_id = threadId;",
+  "daemonWs.send(text);",
+  "web route thread is injected before forwarding to daemon",
+);
 assertBefore(
   "registerCodexE2eeSessionRoute(identity.agentId, envelope.session, threadId, ws);",
   "daemonWs.send(text);",

package/scripts/test-crc-pair-login-flow.mjs

@@ -12,6 +12,12 @@ function assertContains(source, needle, label) {
   }
 }
 
+function assertNotContains(source, needle, label) {
+  if (source.includes(needle)) {
+    throw new Error(`${label} must not contain: ${needle}`);
+  }
+}
+
 function assertBefore(source, first, second, label) {
   const firstIndex = source.indexOf(first);
   const secondIndex = source.indexOf(second);
@@ -20,15 +26,74 @@ function assertBefore(source, first, second, label) {
   }
 }
 
+function extractServerNextSanitizer(source) {
+  const consts = [
+    source.match(/const PAIR_NEXT_REGEX = .+;/)?.[0],
+    source.match(/const REMOTE_CONTROL_NEXT_REGEX = .+;/)?.[0],
+    source.match(/const DEMO_NEXT_REGEX = .+;/)?.[0],
+  ];
+  if (consts.some((line) => !line)) {
+    throw new Error("server sanitizer test could not extract next regex constants");
+  }
+  const start = source.indexOf("function sanitizeCrcPairNext(raw)");
+  const end = source.indexOf("// POST /api/qr-login", start);
+  if (start === -1 || end === -1) {
+    throw new Error("server sanitizer test could not extract sanitizeCrcPairNext");
+  }
+  return Function(`${consts.join("\n")}\n${source.slice(start, end)}\nreturn sanitizeCrcPairNext;`)();
+}
+
+function assertSanitizedNext(sanitize, value, expected) {
+  const actual = sanitize(value);
+  if (actual !== expected) {
+    throw new Error(`sanitizeCrcPairNext(${JSON.stringify(value)}) expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
 assertContains(server, "const PAIR_NEXT_REGEX = /^\\/pair\\/[ABCDEFGHJKLMNPQRSTUVWXYZ23456789]{6}$/;", "server pair regex");
 assertContains(server, "const REMOTE_CONTROL_NEXT_REGEX = /^\\/codex-remote-control\\/", "server remote-control regex");
+assertContains(server, "const DEMO_NEXT_REGEX = /^\\/demo$/;", "server demo regex");
 assertContains(server, "purpose,           // \"pair\" | null", "server stores pair purpose");
-assertContains(server, "next: next || null, // sanitized `/pair/<CODE>` or null", "server stores sanitized next");
+assertContains(server, "next: next || null, // sanitized `/pair/<CODE>`, `/codex-remote-control/<UUID>`, `/demo`, or null", "server stores sanitized next");
+assertContains(server, "DEMO_NEXT_REGEX.test(decoded)", "server allows demo next");
 assertContains(server, "json(res, 200, { status: \"approved\", agentId: entry.agentId });", "server strips desktop pair status");
 assertContains(server, "json(res, 200, { ok: true, next: entry.next });", "server returns next to phone approve");
+assertContains(server, "tenantId: entry.tenantId || null,", "server returns QR login tenant");
+assertContains(server, "const verifiedIdentity = identityForApiKey(apiKey);", "server canonicalizes QR approval identity");
+
+const sanitizeCrcPairNext = extractServerNextSanitizer(server);
+assertSanitizedNext(sanitizeCrcPairNext, "/demo", "/demo");
+assertSanitizedNext(sanitizeCrcPairNext, "/demo/", null);
+assertSanitizedNext(sanitizeCrcPairNext, "/demo/../admin", null);
+assertSanitizedNext(sanitizeCrcPairNext, "//evil.com", null);
+assertSanitizedNext(sanitizeCrcPairNext, "https://evil", null);
+assertSanitizedNext(sanitizeCrcPairNext, "/demoX", null);
 
 for (const file of loginFiles) {
   const html = readFileSync(file, "utf8");
+  assertContains(html, "var DEMO_NEXT_REGEX = /^\\/demo$/;", `${file} demo regex`);
+  assertContains(html, "function defaultLocalPasskeysOn()", `${file} has local passkey default helper`);
+  assertContains(html, "return isMobileDevice();", `${file} defaults local passkeys on for mobile`);
+  assertContains(html, "function getLocalPasskeysPreference()", `${file} has local passkey preference helper`);
+  assertContains(html, "if (stored === 'on' || stored === 'off') return stored;", `${file} respects stored local passkey preference`);
+  assertContains(html, "function needsCustomQR() {\n  return !isLocalPasskeysOn();\n}", `${file} uses QR whenever local passkeys are off`);
+  assertNotContains(html, "return !isMobileDevice() && !isSafariDesktop() && !isLocalPasskeysOn();", `${file} must not gate QR by browser or mobile status`);
+  assertContains(html, "DEMO_NEXT_REGEX.test(raw)", `${file} allowlists demo next`);
+  assertContains(html, "function storeDemoHandoffIfNeeded(next, identity, isNewAccount)", `${file} demo handoff helper`);
+  assertContains(html, "sessionStorage.setItem('lesa-token', identity.apiKey);", `${file} stores demo token`);
+  assertContains(html, "sessionStorage.setItem('lesa-agent', identity.agentId);", `${file} stores demo agent`);
+  assertContains(html, "if (identity.tenantId) sessionStorage.setItem('lesa-tenant', identity.tenantId);", `${file} stores demo tenant`);
+  assertContains(html, "if (isNewAccount) sessionStorage.setItem('lesa-new-account', 'true');", `${file} stores demo new-account flag conditionally`);
+  assertContains(html, "tenantId: result.tenantId,", `${file} sends tenant to QR approval`);
+  assertContains(html, "storeDemoHandoffIfNeeded(data.next, data, qrLoginMode === 'register');", `${file} QR status stores demo handoff`);
+  assertContains(html, "storeDemoHandoffIfNeeded('/demo', data, qrLoginMode === 'register');", `${file} plain QR success keeps demo handoff`);
+  assertContains(html, "storeDemoHandoffIfNeeded('/demo', result, true);", `${file} plain create success keeps demo handoff`);
+  assertContains(html, "storeDemoHandoffIfNeeded('/demo', result, false);", `${file} plain sign-in success keeps demo handoff`);
+  if (html.includes('onclick="sessionStorage.clear();"')) {
+    throw new Error(`${file} Try the Demo button must not clear sessionStorage`);
+  }
+  assertContains(html, "followPairNextIfPresent(approveResponse, result, true)", `${file} create account marks new account`);
+  assertContains(html, "followPairNextIfPresent(approveResponse, result, false)", `${file} sign-in does not mark new account`);
   assertContains(html, "function isPairNextOnDesktop()", `${file} desktop pair helper`);
   assertContains(html, "} else if (isPairNextOnDesktop()) {", `${file} auto-start desktop pair QR`);
   assertContains(html, "startQrLogin('', 'signin');", `${file} pair QR uses sign-in mode`);
@@ -37,4 +102,14 @@ for (const file of loginFiles) {
   assertBefore(html, "if (isPairNextOnDesktop() && !qrSessionMode)", "if (needsCustomQR() && !qrSessionMode)", `${file} create button forces pair QR before normal QR fallback`);
 }
 
+const appLogin = readFileSync("src/hosted-mcp/app/kaleidoscope-login.html", "utf8");
+assertContains(appLogin, "Local passkeys are on by default on mobile devices.", "app login mobile tooltip copy");
+assertContains(appLogin, "This device's passkeys are used for login and device sync.", "app login mobile tooltip current-device copy");
+assertContains(appLogin, "Turn this off to use or save passkeys on a different device.", "app login mobile tooltip off copy");
+assertContains(appLogin, "Local passkeys are off by default on desktop.", "app login desktop tooltip copy");
+assertContains(appLogin, "Your mobile device's passkeys are used for login and device sync.", "app login desktop tooltip mobile-device copy");
+assertContains(appLogin, "Turn this on to use or save passkeys on this computer.", "app login desktop tooltip on copy");
+assertNotContains(appLogin, "phone's passkeys", "app login tooltip must not say phone passkeys");
+assertNotContains(appLogin, "mobile devices' passkeys", "app login tooltip must not use plural possessive");
+
 console.log("crc pair login flow checks passed");