@wipcomputer/wip-ldm-os 0.4.85-alpha.30 → 0.4.85-alpha.32

package/bin/ldm.js

@@ -3099,6 +3099,109 @@ async function cmdDoctor() {
     }
   }
 
+  // Duplicate hook entries + invalid model value in ~/.claude/settings.json.
+  // Duplicates: the same hook (event + matcher + commands) registered more
+  // than once runs once per copy every session. 10 duplicate SessionStart
+  // boot-hook entries observed 2026-07-04 (~450KB of boot context per
+  // session start). Invalid model: a paste carrying ANSI escape codes can
+  // land in /model and get persisted (e.g. "opus" + ESC + "[1m"); every new
+  // session then fails its first API call. The corruption signal is a
+  // CONTROL character (ESC 0x1B etc.), never the visible charset: bracketed
+  // IDs like "claude-fable-5[1m]" are legitimate 1M-context variants and
+  // must be left untouched.
+  // Reported always; collapsed/removed under --fix with a timestamped
+  // backup written before the first mutation.
+  // See ai/product/bugs/installer/open-tickets/2026-07-04--cc-mini--installer-sessionstart-hook-duplicate-registration.md
+  // and ai/product/bugs/guard/2026-07-04--cc-mini--no-blessed-recipe-for-live-settings-remediation.md
+  {
+    const settingsPath = join(HOME, '.claude', 'settings.json');
+    const settings = readJSON(settingsPath);
+    if (!settings && existsSync(settingsPath)) {
+      console.log('  ! ~/.claude/settings.json exists but is not valid JSON; skipping hook/model checks');
+      issues++;
+    }
+    let settingsDirty = false;
+    let backupDone = false;
+    const backupSettingsOnce = () => {
+      if (backupDone) return;
+      const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const bak = `${settingsPath}.bak-${stamp}`;
+      copyFileSync(settingsPath, bak);
+      console.log(`  + Backup written: ${bak}`);
+      backupDone = true;
+    };
+
+    // Duplicate hook entries (same event + matcher + hook command list).
+    // Deliberately ignores type/timeout: entries differing only in timeout
+    // are treated as duplicates and collapse to the first.
+    if (settings?.hooks) {
+      const dupes = [];
+      for (const [event, groups] of Object.entries(settings.hooks)) {
+        if (!Array.isArray(groups)) continue;
+        const seen = new Map();
+        groups.forEach((g, i) => {
+          const key = JSON.stringify({
+            matcher: g?.matcher,
+            hooks: (g?.hooks || []).map((h) => h?.command),
+          });
+          if (!seen.has(key)) seen.set(key, []);
+          seen.get(key).push(i);
+        });
+        for (const idxs of seen.values()) {
+          if (idxs.length > 1) dupes.push({ event, idxs });
+        }
+      }
+      const extra = dupes.reduce((n, d) => n + d.idxs.length - 1, 0);
+      if (extra > 0) {
+        for (const d of dupes) {
+          const cmd = settings.hooks[d.event][d.idxs[0]]?.hooks?.[0]?.command || '(no command)';
+          console.log(`  ! ${d.event}: ${d.idxs.length} identical hook entries for: ${cmd}`);
+        }
+        if (FIX_FLAG) {
+          backupSettingsOnce();
+          for (const d of dupes) {
+            // Keep the first, drop the rest. Right-to-left so indices stay valid.
+            for (let j = d.idxs.length - 1; j >= 1; j--) {
+              settings.hooks[d.event].splice(d.idxs[j], 1);
+            }
+          }
+          settingsDirty = true;
+          console.log(`  + Collapsed ${extra} duplicate hook entr${extra === 1 ? 'y' : 'ies'}`);
+        } else {
+          console.log(`    Run: ldm doctor --fix to collapse ${extra} duplicate hook entr${extra === 1 ? 'y' : 'ies'}`);
+          issues += extra;
+        }
+      }
+    }
+
+    // Invalid model value. Corruption means CONTROL characters (ESC 0x1B
+    // from ANSI fragments, NUL, DEL...) or an impossible length, never a
+    // visible-charset judgment: "claude-fable-5[1m]" is a legitimate
+    // 1M-context model ID and must pass.
+    if (settings && typeof settings.model === 'string') {
+      const valid =
+        settings.model.length > 0 &&
+        settings.model.length <= 256 &&
+        !/[\x00-\x1f\x7f]/.test(settings.model);
+      if (!valid) {
+        console.log(`  ! settings.json model value is invalid: ${JSON.stringify(settings.model)}`);
+        if (FIX_FLAG) {
+          backupSettingsOnce();
+          delete settings.model;
+          settingsDirty = true;
+          console.log('  + Removed invalid model value (re-pick with /model in Claude Code)');
+        } else {
+          console.log('    Run: ldm doctor --fix to remove it, then re-pick with /model in Claude Code');
+          issues++;
+        }
+      }
+    }
+
+    if (settingsDirty) {
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    }
+  }
+
   // --fix: clean registry entries with /tmp/ sources or ldm-install- names (#54)
   if (FIX_FLAG) {
     const registry = readJSON(REGISTRY_PATH);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.85-alpha.30",
+  "version": "0.4.85-alpha.32",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {
@@ -33,6 +33,7 @@
     "test:installer-skill-dry-run-destinations": "node scripts/test-installer-skill-dry-run-destinations.mjs",
     "test:ldm-install-bin-shim": "node scripts/test-ldm-install-preserves-foreign-bin.mjs",
     "test:doctor-cron-target": "node scripts/test-doctor-cron-target.mjs",
+    "test:boot-payload-trim": "node scripts/test-boot-payload-trim.mjs",
     "test:bin-manifest": "node scripts/test-bin-manifest.mjs",
     "test:crc-agentid-tenant-boundary": "node scripts/test-crc-agentid-tenant-boundary.mjs",
     "test:crc-pair-login-flow": "node scripts/test-crc-pair-login-flow.mjs",
@@ -41,8 +42,13 @@
     "test:crc-e2ee-key-persistence": "node scripts/test-crc-e2ee-key-persistence.mjs",
     "test:crc-e2ee-session-route": "node scripts/test-crc-e2ee-session-route.mjs",
     "test:crc-websocket-abuse-limits": "node scripts/test-crc-websocket-abuse-limits.mjs",
+    "test:kaleidoscope-qr-authenticator-confirmation": "node scripts/test-kaleidoscope-qr-authenticator-confirmation.mjs",
+    "test:kaleidoscope-onboarding-copy": "node scripts/test-kaleidoscope-onboarding-copy.mjs",
+    "test:kaleidoscope-public-stats-baseline": "node scripts/test-kaleidoscope-public-stats-baseline.mjs",
     "fmt": "npx prettier --write 'src/**/*.{ts,mjs}' 'lib/**/*.mjs' 'bin/**/*.js'",
-    "fmt:check": "npx prettier --check 'src/**/*.{ts,mjs}' 'lib/**/*.mjs' 'bin/**/*.js'"
+    "fmt:check": "npx prettier --check 'src/**/*.{ts,mjs}' 'lib/**/*.mjs' 'bin/**/*.js'",
+    "test:boot-hook-registration": "node scripts/test-boot-hook-registration.mjs",
+    "test:doctor-hook-dedupe": "node scripts/test-doctor-hook-dedupe.mjs"
   },
   "claudeCode": {
     "hook": {

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-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");