@logicseek/hello-cc 0.1.5 → 0.1.6

package/scripts/regression.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 
 import fs from 'node:fs';
+import http from 'node:http';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { DatabaseSync } from 'node:sqlite';
 import { Readable } from 'node:stream';
+import { pathToFileURL } from 'node:url';
 import WebSocket from 'ws';
 
 const repoRoot = path.resolve(import.meta.dirname, '..');
@@ -18,6 +21,11 @@ const home = path.join(os.tmpdir(), `hcc-reg-home-${testId}`);
 const fakeBin = path.join(os.tmpdir(), `hcc-reg-bin-${testId}`);
 const outDir = path.join(os.tmpdir(), `hcc-reg-out-${testId}`);
 const tmuxSession = `hcc-reg-${process.pid}`;
+const tmuxSocketName = `hcc-reg-${testId}`.replace(/[^A-Za-z0-9_-]/g, '-');
+const realTmuxBin = spawnSync('sh', ['-lc', 'command -v tmux || true'], {
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'ignore']
+}).stdout.trim();
 const port = 22000 + (process.pid % 10000);
 
 let tmuxStarted = false;
@@ -32,6 +40,8 @@ const env = {
 for (const key of Object.keys(env)) {
   if (key.startsWith('HCC_')) delete env[key];
 }
+delete env.TMUX;
+delete env.TMUX_PANE;
 
 function log(message) {
   process.stdout.write(`${message}\n`);
@@ -49,6 +59,19 @@ function sh(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
 
+function shortHash(value) {
+  return crypto.createHash('sha1').update(String(value)).digest('hex').slice(0, 8);
+}
+
+function sanitizePeerPart(value, fallback = 'peer') {
+  const cleaned = String(value || '').toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+  return cleaned || fallback;
+}
+
+function tmuxManagedSession(projectRoot, peer) {
+  return `hcc-${shortHash(projectRoot)}-${sanitizePeerPart(peer, 'peer')}`.slice(0, 80);
+}
+
 function run(command, args, options = {}) {
   const result = spawnSync(command, args, {
     cwd: options.cwd || repoRoot,
@@ -183,6 +206,14 @@ function insertRuntimeTargetBinding(peer, provider, sessionName, runtimeTarget)
   });
 }
 
+function peerBindingRow(peer) {
+  return withMeshDb((db) => db.prepare(`
+    SELECT peer, transport, runtime_target, updated_at
+    FROM peer_bindings
+    WHERE peer = ?
+  `).get(peer));
+}
+
 function moveRuntimeBindingPeer(fromPeer, toPeer) {
   withMeshDb((db) => {
     const peer = db.prepare('SELECT * FROM peers WHERE id = ?').get(fromPeer);
@@ -270,6 +301,162 @@ function assertPeerBindingUniqueConstraints() {
   cleanupBindingPeers(runtimePrefix);
 }
 
+async function assertTmuxGcPolicy() {
+  const stalePeer = 'tmux-gc-stale';
+  const peerFilterPeer = 'tmux-gc-peer-filter';
+  const attachedPeer = 'tmux-gc-attached';
+  const eventPeer = 'tmux-gc-event';
+  const reusedEventPeer = 'tmux-gc-event-reused';
+  const manualSession = `hcc-${shortHash(root)}-manual-lookalike`;
+  const staleSession = tmuxManagedSession(root, stalePeer);
+  const peerFilterSession = tmuxManagedSession(root, peerFilterPeer);
+  const attachedSession = tmuxManagedSession(root, attachedPeer);
+  const eventSession = `${tmuxManagedSession(root, eventPeer)}-old-regression`;
+  const reusedEventSession = tmuxManagedSession(root, reusedEventPeer);
+  for (const session of [staleSession, peerFilterSession, attachedSession, eventSession, reusedEventSession, manualSession]) {
+    runMaybe('tmux', ['kill-session', '-t', session]);
+  }
+  cleanupBindingPeers('tmux-gc-');
+  managedTmuxSessions.add(peerFilterSession);
+  managedTmuxSessions.add(attachedSession);
+  managedTmuxSessions.add(eventSession);
+  managedTmuxSessions.add(reusedEventSession);
+  managedTmuxSessions.add(manualSession);
+
+  run('tmux', ['new-session', '-d', '-s', staleSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  run('tmux', ['new-session', '-d', '-s', peerFilterSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  run('tmux', ['new-session', '-d', '-s', attachedSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  run('tmux', ['new-session', '-d', '-s', eventSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  run('tmux', ['new-session', '-d', '-s', reusedEventSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  run('tmux', ['new-session', '-d', '-s', manualSession, '-e', `HCC_ROOT=${root}`, '-c', root, 'bash', '--noprofile', '--norc']);
+  const stalePane = run('tmux', ['display-message', '-p', '-t', `${staleSession}:0.0`, '#{pane_id}']).trim();
+  const peerFilterPane = run('tmux', ['display-message', '-p', '-t', `${peerFilterSession}:0.0`, '#{pane_id}']).trim();
+  const attachedPane = run('tmux', ['display-message', '-p', '-t', `${attachedSession}:0.0`, '#{pane_id}']).trim();
+  const eventPane = run('tmux', ['display-message', '-p', '-t', `${eventSession}:0.0`, '#{pane_id}']).trim();
+  const reusedEventPane = run('tmux', ['display-message', '-p', '-t', `${reusedEventSession}:0.0`, '#{pane_id}']).trim();
+  const manualPane = run('tmux', ['display-message', '-p', '-t', `${manualSession}:0.0`, '#{pane_id}']).trim();
+  insertRuntimeTargetBinding(stalePeer, 'shell', 'tmux-gc-stale-session', stalePane);
+  insertRuntimeTargetBinding(peerFilterPeer, 'shell', 'tmux-gc-peer-filter-session', peerFilterPane);
+  insertRuntimeTargetBinding(attachedPeer, 'shell', 'tmux-gc-attached-session', attachedPane);
+  const eventActivePane = parsePane(hcc(['peer', 'start', eventPeer, '--kind', 'shell', '--', 'bash', '--noprofile', '--norc']));
+  const eventActiveSession = run('tmux', ['display-message', '-p', '-t', eventActivePane, '#{session_name}']).trim();
+  withMeshDb((db) => {
+    const t = Math.floor(Date.now() / 1000) - 30 * 86400;
+    db.prepare('UPDATE peers SET last_seen_at = ? WHERE id IN (?, ?, ?)').run(t, stalePeer, peerFilterPeer, attachedPeer);
+    db.prepare('UPDATE peer_bindings SET updated_at = ? WHERE peer IN (?, ?, ?)').run(t, stalePeer, peerFilterPeer, attachedPeer);
+    db.prepare(`
+      INSERT INTO events(type, actor, task_id, payload, created_at)
+      VALUES ('tmux.session.rebind_cleanup_failed', ?, NULL, ?, ?)
+    `).run(eventPeer, JSON.stringify({
+      reason: 'has_clients',
+      old_peer: eventPeer,
+      old_runtime_target: eventPane,
+      new_runtime_target: eventActivePane,
+      old_tmux_session: eventSession
+    }), t);
+    db.prepare(`
+      INSERT INTO events(type, actor, task_id, payload, created_at)
+      VALUES ('tmux.session.rebind_cleanup_failed', ?, NULL, ?, ?)
+    `).run(reusedEventPeer, JSON.stringify({
+      reason: 'has_clients',
+      old_peer: reusedEventPeer,
+      old_runtime_target: `%dead-old-${process.pid}`,
+      new_runtime_target: `%new-${process.pid}`,
+      old_tmux_session: reusedEventSession
+    }), t);
+  });
+
+  const client = spawnSync('tmux', ['new-session', '-d', '-s', `${tmuxSession}-gc-client`, '-e', `HCC_ROOT=${root}`, 'sh', '-lc', `unset TMUX; exec tmux attach-session -t ${sh(attachedSession)}`], {
+    env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (client.status !== 0) fail(`could not attach client for tmux gc policy test:\n${client.stderr || client.stdout}`);
+  try {
+    await waitFor(() => Boolean(run('tmux', ['list-clients', '-t', attachedSession, '-F', '#{client_tty}']).trim()), 'tmux gc attached-client setup');
+    const dryRun = hcc(['tmux', 'gc', '--older-than', '14']);
+    if (!dryRun.includes(stalePeer) || !dryRun.includes('stale_hcc_managed_session') ||
+        !dryRun.includes(peerFilterPeer) ||
+        !dryRun.includes(eventPeer) || !dryRun.includes('stale_rebind_cleanup_failed_session')) {
+      fail(`tmux gc dry-run did not list stale DB-proven managed session:\n${dryRun}`);
+    }
+    if (dryRun.includes(reusedEventPeer)) {
+      fail(`tmux gc dry-run treated stale event session-name reuse as removable:\n${dryRun}`);
+    }
+    if (runMaybe('tmux', ['has-session', '-t', staleSession]).status !== 0) {
+      fail('tmux gc dry-run deleted stale managed session');
+    }
+    const filteredDryRun = hcc(['tmux', 'gc', '--older-than', '14', '--peer', peerFilterPeer]);
+    if (!filteredDryRun.includes(peerFilterPeer) || filteredDryRun.includes(stalePeer) || filteredDryRun.includes(eventPeer)) {
+      fail(`tmux gc --peer dry-run did not filter to requested peer:\n${filteredDryRun}`);
+    }
+    const filteredRemoved = hcc(['tmux', 'gc', '--older-than', '14', '--peer', peerFilterPeer, '--yes']);
+    if (!filteredRemoved.includes(peerFilterPeer) || filteredRemoved.includes(stalePeer) || filteredRemoved.includes(eventPeer)) {
+      fail(`tmux gc --peer --yes did not remove only requested peer:\n${filteredRemoved}`);
+    }
+    if (runMaybe('tmux', ['has-session', '-t', peerFilterSession]).status === 0) {
+      fail('tmux gc --peer --yes did not delete requested stale managed session');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', staleSession]).status !== 0 ||
+        runMaybe('tmux', ['has-session', '-t', eventSession]).status !== 0) {
+      fail('tmux gc --peer --yes deleted an unrequested stale managed session');
+    }
+
+    const removed = hcc(['tmux', 'gc', '--older-than', '14', '--yes']);
+    if (!removed.includes(stalePeer) || !removed.includes(eventPeer) || removed.includes(peerFilterPeer) || removed.includes(attachedPeer) || removed.includes(manualPane)) {
+      fail(`tmux gc --yes output wrong:\n${removed}`);
+    }
+    if (runMaybe('tmux', ['has-session', '-t', staleSession]).status === 0) {
+      fail('tmux gc --yes did not delete stale DB-proven managed session');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', eventSession]).status === 0) {
+      fail('tmux gc --yes did not delete stale rebind cleanup-failed session');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', eventActiveSession]).status !== 0) {
+      fail('tmux gc deleted the active replacement session for the same peer');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', reusedEventSession]).status !== 0) {
+      fail('tmux gc deleted a same-name session whose old runtime target no longer matched');
+    }
+    if (run('tmux', ['display-message', '-p', '-t', `${reusedEventSession}:0.0`, '#{pane_id}']).trim() !== reusedEventPane) {
+      fail('tmux gc touched the wrong same-name rebind cleanup session');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', attachedSession]).status !== 0) {
+      fail('tmux gc deleted managed session with attached tmux client');
+    }
+    if (runMaybe('tmux', ['has-session', '-t', manualSession]).status !== 0) {
+      fail('tmux gc deleted manual lookalike tmux session without DB binding');
+    }
+    const staleBinding = peerBindingRow(stalePeer);
+    if (!staleBinding || staleBinding.transport !== 'detached' || staleBinding.runtime_target !== null) {
+      fail(`tmux gc did not detach deleted binding:\n${JSON.stringify(staleBinding, null, 2)}`);
+    }
+    const peerFilterBinding = peerBindingRow(peerFilterPeer);
+    if (!peerFilterBinding || peerFilterBinding.transport !== 'detached' || peerFilterBinding.runtime_target !== null) {
+      fail(`tmux gc --peer did not detach requested deleted binding:\n${JSON.stringify(peerFilterBinding, null, 2)}`);
+    }
+    const attachedBinding = peerBindingRow(attachedPeer);
+    if (!attachedBinding || attachedBinding.runtime_target !== attachedPane) {
+      fail(`tmux gc changed attached-client binding:\n${JSON.stringify(attachedBinding, null, 2)}`);
+    }
+    const eventBinding = peerBindingRow(eventPeer);
+    if (!eventBinding || eventBinding.runtime_target !== eventActivePane) {
+      fail(`tmux gc changed active replacement binding for event-backed stale session:\n${JSON.stringify(eventBinding, null, 2)}`);
+    }
+  } finally {
+    hccMaybe(['peer', 'stop', eventPeer, '--kill-tmux']);
+    runMaybe('tmux', ['kill-session', '-t', `${tmuxSession}-gc-client`]);
+    runMaybe('tmux', ['kill-session', '-t', peerFilterSession]);
+    runMaybe('tmux', ['kill-session', '-t', attachedSession]);
+    runMaybe('tmux', ['kill-session', '-t', eventSession]);
+    runMaybe('tmux', ['kill-session', '-t', reusedEventSession]);
+    runMaybe('tmux', ['kill-session', '-t', eventActiveSession]);
+    runMaybe('tmux', ['kill-session', '-t', manualSession]);
+    runMaybe('tmux', ['kill-session', '-t', staleSession]);
+    cleanupBindingPeers('tmux-gc-');
+  }
+}
+
 function createLegacyBindingDb(dbPath) {
   fs.mkdirSync(path.dirname(dbPath), { recursive: true });
   const db = new DatabaseSync(dbPath);
@@ -592,6 +779,26 @@ function trackTmuxPane(pane) {
   if (result.status === 0) managedTmuxSessions.add(result.stdout.trim());
 }
 
+function tmuxEnvironmentValue(session, key) {
+  const result = runMaybe('tmux', ['show-environment', '-t', session, key]);
+  if (result.status !== 0) return null;
+  const line = (result.stdout || '').trim();
+  const prefix = `${key}=`;
+  return line.startsWith(prefix) ? line.slice(prefix.length) : null;
+}
+
+function assertHccManagedTmuxEnv(pane, expectedRoot = root) {
+  const session = run('tmux', ['display-message', '-p', '-t', pane, '#{session_name}']).trim();
+  const hccRoot = tmuxEnvironmentValue(session, 'HCC_ROOT');
+  const hccDb = tmuxEnvironmentValue(session, 'HCC_DB');
+  const expectedDb = path.join(expectedRoot, '.hello-cc', 'mesh.db');
+  if (path.resolve(hccRoot || '') !== path.resolve(expectedRoot) ||
+      path.resolve(hccDb || '') !== path.resolve(expectedDb)) {
+    fail(`hcc-managed tmux session missing root/db markers: ${session} HCC_ROOT=${hccRoot} HCC_DB=${hccDb}`);
+  }
+  return session;
+}
+
 function parsePane(output) {
   const match = String(output).match(/\bpane=(%\d+)/);
   if (!match) fail(`cannot parse tmux pane from:\n${output}`);
@@ -888,6 +1095,10 @@ async function expectBoundedTmuxStream(label) {
 
 function writeFakeTools() {
   fs.mkdirSync(fakeBin, { recursive: true });
+  if (realTmuxBin) {
+    const tmuxWrapper = path.join(fakeBin, 'tmux');
+    fs.writeFileSync(tmuxWrapper, `#!/usr/bin/env bash\nexec ${sh(realTmuxBin)} -L ${sh(tmuxSocketName)} "$@"\n`, { mode: 0o755 });
+  }
   for (const name of ['claude', 'codex']) {
     const file = path.join(fakeBin, name);
     fs.writeFileSync(file, `#!/usr/bin/env bash\necho fake-${name} "$@"\nif [ -n "\${HCC_FAKE_LOG:-}" ]; then echo fake-${name} "$@" >> "$HCC_FAKE_LOG"; fi\nif [ "\${HCC_FAKE_STAY_ALIVE:-}" = "1" ]; then exec bash --noprofile --norc; fi\n`, { mode: 0o755 });
@@ -934,6 +1145,9 @@ function cleanup() {
   for (const session of managedTmuxSessions) {
     runMaybe('tmux', ['kill-session', '-t', session]);
   }
+  if (fs.existsSync(path.join(fakeBin, 'tmux'))) {
+    runMaybe('tmux', ['kill-server']);
+  }
   for (const dir of [root, home, fakeBin, outDir]) {
     try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
   }
@@ -1687,6 +1901,11 @@ async function multiProjectWebWorkflow() {
   if (!(otherSessions.sessions || []).some((s) => s.id === 'other-shell')) {
     fail(`second project API did not see its session:\n${JSON.stringify(otherSessions)}`);
   }
+  const otherShellSession = (otherSessions.sessions || []).find((s) => s.id === 'other-shell');
+  if (!otherShellSession?.binding || otherShellSession.binding.runtime_target !== otherShellSession.pane ||
+      otherShellSession.provider_session_known !== false || otherShellSession.provider_session_label !== null) {
+    fail(`sessions API did not expose unknown provider binding without marking it shared/known:\n${JSON.stringify(otherShellSession, null, 2)}`);
+  }
 
   hcc(['register', '--peer', 'web-action-peer', '--kind', 'codex', '--role', 'peer']);
   hcc(['msg', 'send', '--from', 'human', '--to', 'web-action-peer', '--body', 'web action inbox ok']);
@@ -1753,6 +1972,9 @@ async function multiProjectWebWorkflow() {
   if (claudeResume.id !== expectedClaudePeer || claudeResume.peer_id !== expectedClaudePeer) {
     fail(`web claude resume did not use canonical provider peer id ${expectedClaudePeer}:\n${JSON.stringify(claudeResume, null, 2)}`);
   }
+  if (!claudeResume.binding || !claudeResume.provider_session_known || claudeResume.provider_session_label !== claudeResumeName) {
+    fail(`web claude resume session response did not include known provider binding:\n${JSON.stringify(claudeResume, null, 2)}`);
+  }
   const claudeRows = providerBindingRows('claude', claudeResumeName);
   if (claudeRows.length !== 1 ||
       claudeRows[0].peer !== claudeResume.peer_id ||
@@ -1773,6 +1995,9 @@ async function multiProjectWebWorkflow() {
   if (codexResume.id !== expectedCodexPeer || codexResume.peer_id !== expectedCodexPeer) {
     fail(`web codex resume did not use canonical provider peer id ${expectedCodexPeer}:\n${JSON.stringify(codexResume, null, 2)}`);
   }
+  if (!codexResume.binding || !codexResume.provider_session_known || codexResume.provider_session_label !== codexResumeName) {
+    fail(`web codex resume session response did not include known provider binding:\n${JSON.stringify(codexResume, null, 2)}`);
+  }
   const codexRows = providerBindingRows('codex', codexResumeName);
   if (codexRows.length !== 1 ||
       codexRows[0].peer !== codexResume.peer_id ||
@@ -1852,6 +2077,7 @@ async function tmuxBackedStartWorkflow() {
   const file = path.join(outDir, 'pty-ok');
   const started = hcc(['peer', 'start', 'shell-a', '--kind', 'shell', '--', 'bash']);
   const pane = parsePane(started);
+  assertHccManagedTmuxEnv(pane);
   const list = hcc(['peer', 'list']);
   if (!list.includes('shell-a') || !list.includes('tmux')) fail(`tmux-backed peer missing from list:\n${list}`);
   hcc(['inject', 'shell-a', `echo PTY_OK > ${file}`]);
@@ -1893,6 +2119,7 @@ async function tmuxBackedStartWorkflow() {
     env: { ...env, HCC_FAKE_STAY_ALIVE: '1' }
   });
   const canonicalPane = parsePane(canonicalStarted);
+  assertHccManagedTmuxEnv(canonicalPane);
   const canonicalRows = providerBindingRows('claude', canonicalSession);
   if (canonicalRows.length !== 1 ||
       canonicalRows[0].peer !== 'claude-live-canonical' ||
@@ -1906,17 +2133,22 @@ async function tmuxBackedStartWorkflow() {
   const forceFirst = hcc(['peer', 'start', 'claude-force-a', '--kind', 'claude', '--resume', forceSession], {
     env: { ...env, HCC_FAKE_STAY_ALIVE: '1' }
   });
-  parsePane(forceFirst);
+  const forceFirstPane = parsePane(forceFirst);
+  const forceFirstSession = run('tmux', ['display-message', '-p', '-t', forceFirstPane, '#{session_name}']).trim();
   const forceConflict = hccMaybe(['peer', 'start', 'claude-force-b', '--kind', 'claude', '--resume', forceSession], {
     env: { ...env, HCC_FAKE_STAY_ALIVE: '1' }
   });
   if (forceConflict.status === 0 || !String(forceConflict.stderr || forceConflict.stdout).includes('already bound to claude-force-a')) {
     fail(`provider session duplicate start was not rejected:\n${forceConflict.stdout}\n${forceConflict.stderr}`);
   }
+  if (runMaybe('tmux', ['has-session', '-t', tmuxManagedSession(root, 'claude-force-b')]).status === 0) {
+    fail('failed duplicate provider start left a new claude-force-b tmux session behind');
+  }
   const forceSecond = hcc(['peer', 'start', 'claude-force-b', '--kind', 'claude', '--resume', forceSession, '--force'], {
     env: { ...env, HCC_FAKE_STAY_ALIVE: '1' }
   });
   const forcePane = parsePane(forceSecond);
+  assertHccManagedTmuxEnv(forcePane);
   const forceRows = providerBindingRows('claude', forceSession);
   if (forceRows.length !== 1 ||
       forceRows[0].peer !== 'claude-force-b' ||
@@ -1924,6 +2156,9 @@ async function tmuxBackedStartWorkflow() {
       forceRows[0].runtime_target !== forcePane) {
     fail(`--force did not move provider binding to replacement tmux peer:\n${JSON.stringify(forceRows, null, 2)}`);
   }
+  if (runMaybe('tmux', ['has-session', '-t', forceFirstSession]).status === 0) {
+    fail('--force provider rebind did not remove old hcc-managed tmux session');
+  }
   hccMaybe(['peer', 'stop', 'claude-force-a']);
   hcc(['peer', 'stop', 'claude-force-b']);
 
@@ -1931,12 +2166,14 @@ async function tmuxBackedStartWorkflow() {
   startRuntime({ env: envWithoutProvider({ HCC_REG_VALUE: 'runtime-old', ANTHROPIC_BASE_URL: 'runtime-old-url' }) });
   await waitRuntime();
   const envFile = path.join(outDir, 'caller-env-ok');
-  parsePane(hcc(['peer', 'start', 'env-a', '--kind', 'shell', '--', 'bash', '--noprofile', '--norc'], {
+  const envPane = parsePane(hcc(['peer', 'start', 'env-a', '--kind', 'shell', '--', 'bash', '--noprofile', '--norc'], {
     env: envWithoutProvider({ HCC_REG_VALUE: 'caller-new' })
   }));
+  assertHccManagedTmuxEnv(envPane);
   hcc(['inject', 'env-a', `printf '%s|%s\\n' "$HCC_REG_VALUE" "\${ANTHROPIC_BASE_URL:-}" > ${envFile}`]);
   await waitForFile(envFile, 'caller-new|', 'caller env propagation');
   hcc(['peer', 'stop', 'env-a']);
+  await assertTmuxGcPolicy();
 }
 
 async function shimTmuxWorkflow() {
@@ -2184,7 +2421,17 @@ async function syntaxAndHelp() {
     run(process.execPath, ['--check', path.join(repoRoot, file)]);
   }
   const hccSource = fs.readFileSync(hccBin, 'utf8');
-  const webUiTemplateSource = fs.readFileSync(path.join(repoRoot, 'lib', 'web-ui-template.mjs'), 'utf8');
+  const coordinationStateSource = fs.readFileSync(path.join(repoRoot, 'lib', 'coordination-state.mjs'), 'utf8');
+  const errorsCompatSource = fs.readFileSync(path.join(repoRoot, 'lib', 'errors.mjs'), 'utf8');
+  const sharedErrorsSource = fs.readFileSync(path.join(repoRoot, 'lib', 'shared', 'errors.mjs'), 'utf8');
+  const setupSource = fs.readFileSync(path.join(repoRoot, 'lib', 'setup.mjs'), 'utf8');
+  const shimScriptCompatSource = fs.readFileSync(path.join(repoRoot, 'lib', 'shim-script.mjs'), 'utf8');
+  const integrationHooksSource = fs.readFileSync(path.join(repoRoot, 'lib', 'integrations', 'hooks.mjs'), 'utf8');
+  const integrationShimsSource = fs.readFileSync(path.join(repoRoot, 'lib', 'integrations', 'shims.mjs'), 'utf8');
+  const integrationShimScriptSource = fs.readFileSync(path.join(repoRoot, 'lib', 'integrations', 'shims', 'script.mjs'), 'utf8');
+  const shellPathSource = fs.readFileSync(path.join(repoRoot, 'lib', 'shell-path.mjs'), 'utf8');
+  const webPeerActionsSource = fs.readFileSync(path.join(repoRoot, 'lib', 'web', 'peer-actions.mjs'), 'utf8');
+  const webUiTemplateSource = fs.readFileSync(path.join(repoRoot, 'lib', 'web', 'ui-template.mjs'), 'utf8');
   for (const expected of [
     'function scheduleTmuxInputRefresh(session)',
     "runTmux(['pipe-pane', '-t', session.pane]);",
@@ -2196,11 +2443,134 @@ async function syntaxAndHelp() {
   ]) {
     if (!hccSource.includes(expected)) fail(`web terminal input refresh support missing: ${expected}`);
   }
+  for (const expected of [
+    'function listTmuxPanesOnce()',
+    'let autoAttachScanInFlight = false;',
+    'if (autoAttachScanInFlight) return;',
+    'const paneByPid = new Map();',
+    'const attached = attachedTmuxState(ctx, db);',
+    'function killOldTmuxForRebind(',
+    'function providerSessionBindingMatches(',
+    'function hccWebProcessMatches(',
+    'function splitProcessArgs(line)',
+    'const { global, rest } = splitGlobalArgs(hccArgs);',
+    "if (rest[0] !== 'web') return false;",
+    'sameResolvedPath(global.root, ctx.root)',
+    'sameResolvedPath(global.db, ctx.dbPath)',
+    'sameResolvedPath(',
+    'async function stopOrphanWebRuntimes(',
+    'await stopOrphanWebRuntimes(ctx, existing.pid || null);',
+    'await stopOrphanWebRuntimes(ctx);',
+    'const restoredTmuxDbs = new Set();',
+    'if (restoredTmuxDbs.has(dbKey)) continue;',
+    'input.rebindOldTmux',
+    'rebindOldTmux: true',
+    'skipProviderRebindCleanup:',
+    'function safeOldTmuxRebindPlan(',
+    'function assertOldTmuxCanRebind(',
+    'TMUX_REBIND_NOT_HCC_MANAGED',
+    'TMUX_REBIND_ROOT_MISMATCH',
+    "addEvent(db, 'tmux.session.rebind_cleanup_pending'",
+    'TMUX_REBIND_OLD_SESSION_IN_USE',
+    "addEvent(db, 'tmux.session.rebind_cleanup_failed'",
+    'function restoreParkedOldTmuxSessions()',
+    'restoreParkedOldTmuxSessions();',
+    'parkedOldTmuxSessions.push',
+    "addEvent(db, 'tmux.session.rebound'",
+    "addEvent(eventDb, 'provider.session.rebound'"
+  ]) {
+    if (!hccSource.includes(expected)) fail(`tmux auto-attach/rebind guard missing: ${expected}`);
+  }
+  if (hccSource.includes("return line.includes(`--root ${root}`) || line.includes(`--db ${db}`);")) {
+    fail('orphan web runtime cleanup still uses substring matching for --root/--db');
+  }
+  for (const expected of [
+    'function safeTmuxKillPlan(projectCtx, db, peerId, expectedTarget)',
+    "binding.transport !== 'tmux'",
+    'const expectedSession = tmuxManagedSessionName(projectCtx, peerId);',
+    "throw new CliError('TMUX_KILL_NOT_HCC_MANAGED'",
+    "throw new CliError('TMUX_KILL_ROOT_MISMATCH'",
+    "throw new CliError('TMUX_KILL_HAS_CLIENTS'",
+    'killDbProvenTmuxSession(reqCtx, db, peerId)',
+    'safeTmuxKillPlan(reqCtx, stopDb, peerId, session.pane || null)'
+  ]) {
+    if (!hccSource.includes(expected)) fail(`tmux kill safety guard missing: ${expected}`);
+  }
+  if (hccSource.includes("if (sessName) tmuxKillSession(sessName);")) {
+    fail('web stop kill_tmux still kills tmux by session name without DB-proven guard');
+  }
+  for (const expected of [
+    'async function cmdTmux(',
+    'async function planTmuxGc(',
+    "validateOpts('tmux gc'",
+    'const dryRun = !opts.yes;',
+    'const targetPeer = opts.peer || null;',
+    'if (targetPeer && row.peer !== targetPeer) continue;',
+    'if (targetPeer && rowPeer !== targetPeer) continue;',
+    "b.transport = 'tmux'",
+    'b.runtime_target IS NOT NULL',
+    'actualSession !== expectedSession',
+    "const hccRoot = tmuxSessionEnvironmentValue(actualSession, 'HCC_ROOT');",
+    "skip('hcc_root_mismatch'",
+    "skip('runtime_managed')",
+    "skip('has_tmux_clients'",
+    "reason: 'stale_hcc_managed_session'",
+    "type IN ('tmux.session.rebind_cleanup_failed', 'tmux.session.rebind_cleanup_pending')",
+    "'stale_rebind_cleanup_failed_session'",
+    "'rebind_cleanup_failed'",
+    "'rebind_cleanup_pending'",
+    "'stale_rebind_cleanup_pending_session'",
+    "SET transport = 'detached'",
+    "addEvent(db, 'tmux.session.gc'"
+  ]) {
+    if (!hccSource.includes(expected)) fail(`tmux gc guard missing: ${expected}`);
+  }
+  const autoAttachSource = hccSource.slice(
+    hccSource.indexOf('function scanAndAttachDetectedPeers()'),
+    hccSource.indexOf('scanAndAttachDetectedPeers();')
+  );
+  if ((autoAttachSource.match(/runTmux\(\['list-panes'/g) || []).length > 0) {
+    fail('auto-attach scan calls tmux list-panes inside scanAndAttachDetectedPeers instead of using listTmuxPanesOnce');
+  }
+  if (!autoAttachSource.includes('panes = listTmuxPanesOnce();')) {
+    fail('auto-attach scan no longer uses one tmux pane listing per tick');
+  }
+  const managedStartSource = hccSource.slice(
+    hccSource.indexOf('function startTmuxManagedSession(input)'),
+    hccSource.indexOf('function restoreTmuxManagedSessions')
+  );
+  if (!managedStartSource.includes('rebindOldTmux: true')) {
+    fail('managed tmux start no longer marks explicit rebind cleanup');
+  }
+  if (!managedStartSource.includes('skipProviderRebindCleanup: oldTmuxTargetsForRebind.length > 0')) {
+    fail('managed tmux start no longer avoids duplicate provider rebind cleanup planning');
+  }
+  for (const expected of [
+    'HCC_ROOT: pctx.root',
+    'HCC_DB: pctx.dbPath',
+    '[LAUNCH_FINGERPRINT_ENV]: env[LAUNCH_FINGERPRINT_ENV]'
+  ]) {
+    if (!managedStartSource.includes(expected)) fail(`managed tmux start no longer marks session env: ${expected}`);
+  }
+  const restoreSource = hccSource.slice(
+    hccSource.indexOf('function restoreTmuxManagedSessions'),
+    hccSource.indexOf('function startPtySession')
+  );
+  if (restoreSource.includes('rebindOldTmux')) {
+    fail('restore path must not kill old tmux sessions as a rebind');
+  }
   for (const expected of [
     'function detectedPeerCanStop(peer)',
     "if (['exited', 'detached'].includes(status)) return false;",
     'const canStop = detectedPeerCanStop(p);',
     '${canStop ?',
+    'function providerSessionKnown(session)',
+    "tr('providerSession') + '=' + sessionProvider(session) + ':' + (value || tr('unknown'))",
+    'sessionCardDetailText(s)',
+    'const activeDetectedPeers = visibleDetected.filter((p) => peerIsActive(p));',
+    'const staleDetectedPeers = visibleDetected.filter((p) => !peerIsActive(p));',
+    "localStorage.setItem('hcc.showStaleDetected'",
+    'id="toggleStaleDetected"',
     "if (e.target.closest('[data-action]')) return;",
     'id="stopKillLabel" data-i18n="dialog.killTmux"',
     'id="stopCancelBtn" type="button" data-i18n="dialog.cancel"',
@@ -2211,44 +2581,2071 @@ async function syntaxAndHelp() {
   if (webUiTemplateSource.includes("p.status === 'running' ?")) {
     fail('detected peer action rendering still depends on status === running instead of liveness');
   }
+  if (webUiTemplateSource.indexOf("const stopDialog = document.getElementById('stopDialog');") >
+      webUiTemplateSource.indexOf("document.getElementById('stopBtn').addEventListener('click'")) {
+    fail('stop dialog DOM references are declared after the stop button handler uses them');
+  }
+  if (webUiTemplateSource.includes("sessionRuntimeNote(s) + (s.command || '')")) {
+    fail('managed session display still uses command text as the primary runtime identity');
+  }
   for (const expected of [
-    'function webPeerAction(projectCtx, peer, action, input = {})',
-    'function claimNextTasksForPeer(db, peer, { force = false, count = 1 } = {})',
-    'function takeOverTaskForPeer(db, peer, id, { reason, policy = ',
-    'function statusSummary(ctx, peer = null, identity = null)',
+    'function sessionBindingForSerialize(db, session, peerId)',
+    'function serializeBindingSummary(binding, session)',
+    'provider_session_known: Boolean(providerSessionLabel)',
+    'provider_session_label: providerSessionLabel'
+  ]) {
+    if (!hccSource.includes(expected)) fail(`sessions API binding summary missing: ${expected}`);
+  }
+  for (const expected of [
+    'import { createWebPeerActions } from \'../lib/web/peer-actions.mjs\'',
+    '} = createWebPeerActions({',
     'const peerActionMatch = url.pathname.match(/^\\/api\\/peers\\/([^/]+)\\/actions\\/([^/]+)$/)',
     "const readOnly = ['status', 'state', 'inbox'].includes(action)",
     "sendJson(res, 200, webPeerAction(reqCtx, peer, action, input));"
   ]) {
     if (!hccSource.includes(expected)) fail(`web peer action API support missing: ${expected}`);
   }
+  for (const helper of [
+    'function webPeerRegister(',
+    'function webPeerHeartbeat(',
+    'function webPeerTaskNext(',
+    'function webPeerTaskTakeover(',
+    'function webPeerLockAcquire(',
+    'function webPeerLockRelease(',
+    'function webPeerInbox(',
+    'function webPeerAction('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds web peer action helper: ${helper}`);
+  }
+  for (const expected of [
+    'function webPeerAction(projectCtx, peer, action, input = {})',
+    'claimNextTasksForPeer(db, peer, { force: Boolean(input.force), count })',
+    'takeOverTaskForPeer(db, peer, id, { reason, policy, staleAfter, source: ',
+    'const status = statusSummary(projectCtx, peer)',
+    "normalized === 'task-next'",
+    "normalized === 'lock-acquire'",
+    "normalized === 'lock-release'"
+  ]) {
+    if (!webPeerActionsSource.includes(expected)) fail(`web peer action helper missing: ${expected}`);
+  }
   const packageVersion = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8')).version;
   const cliVersion = run(process.execPath, [hccBin, '--version']).trim();
   if (cliVersion !== packageVersion) {
     fail(`CLI version ${cliVersion} does not match package.json ${packageVersion}`);
   }
+  const releasePackageMeta = await import(path.join(repoRoot, 'lib', 'release', 'package-meta.mjs'));
+  const releaseNotesModule = await import(path.join(repoRoot, 'lib', 'release', 'release-notes.mjs'));
+  const compatPackageMeta = await import(path.join(repoRoot, 'lib', 'package-meta.mjs'));
+  const compatReleaseNotes = await import(path.join(repoRoot, 'lib', 'release-notes.mjs'));
+  for (const [moduleName, mod, names] of [
+    ['release/package-meta', releasePackageMeta, ['packageRoot', 'readJson', 'readPackageJson', 'readPackageMeta']],
+    ['release/release-notes', releaseNotesModule, ['normalizeVersion', 'releaseSection', 'validateReleaseSection', 'repoFromPackage']],
+    ['package-meta compat', compatPackageMeta, ['packageRoot', 'readJson', 'readPackageJson', 'readPackageMeta']],
+    ['release-notes compat', compatReleaseNotes, ['normalizeVersion', 'releaseSection', 'validateReleaseSection', 'repoFromPackage']]
+  ]) {
+    for (const name of names) {
+      if (typeof mod[name] !== 'function') fail(`${moduleName} missing export: ${name}`);
+    }
+  }
+  const releaseScriptRoot = releasePackageMeta.packageRoot(
+    pathToFileURL(path.join(repoRoot, 'scripts', 'release-notes.mjs')).href
+  );
+  if (releaseScriptRoot !== repoRoot) {
+    fail(`release packageRoot resolved ${releaseScriptRoot}, expected ${repoRoot}`);
+  }
+  const releaseNotesScriptSource = fs.readFileSync(path.join(repoRoot, 'scripts', 'release-notes.mjs'), 'utf8');
+  const githubReleaseScriptSource = fs.readFileSync(path.join(repoRoot, 'scripts', 'github-release.mjs'), 'utf8');
+  if (!releaseNotesScriptSource.includes("../lib/release/package-meta.mjs") ||
+      !releaseNotesScriptSource.includes("../lib/release/release-notes.mjs") ||
+      !githubReleaseScriptSource.includes("../lib/release/package-meta.mjs") ||
+      !githubReleaseScriptSource.includes("../lib/release/release-notes.mjs")) {
+    fail('release scripts do not import release helpers from lib/release');
+  }
+  const dbSchema = await import(path.join(repoRoot, 'lib', 'db', 'schema.mjs'));
+  const compatDbSchema = await import(path.join(repoRoot, 'lib', 'db-schema.mjs'));
+  for (const [moduleName, mod] of [
+    ['db/schema', dbSchema],
+    ['db-schema compat', compatDbSchema]
+  ]) {
+    if (typeof mod.DB_SCHEMA_VERSION !== 'number') fail(`${moduleName} missing DB_SCHEMA_VERSION export`);
+    for (const name of ['execWithBusyRetry', 'initSchema', 'readSchemaVersion', 'tx']) {
+      if (typeof mod[name] !== 'function') fail(`${moduleName} missing export: ${name}`);
+    }
+  }
   if (!hccSource.includes("import { readPackageMeta } from '../lib/package-meta.mjs'") ||
       !hccSource.includes("} from '../lib/cli-args.mjs'") ||
-      !hccSource.includes("import { CliError } from '../lib/errors.mjs'") ||
-      !hccSource.includes("} from '../lib/db-schema.mjs'") ||
+      !hccSource.includes("import { CliError } from '../lib/shared/errors.mjs'") ||
+      !hccSource.includes("} from '../lib/db/schema.mjs'") ||
+      !hccSource.includes("} from '../lib/cli-runtime.mjs'") ||
+      !hccSource.includes("import { createCoordinationState } from '../lib/coordination-state.mjs'") ||
+      !hccSource.includes("import { createWebPeerActions } from '../lib/web/peer-actions.mjs'") ||
       !hccSource.includes("} from '../lib/format.mjs'") ||
-      !hccSource.includes("} from '../lib/runtime-paths.mjs'") ||
-      !hccSource.includes("} from '../lib/web-runtime.mjs'") ||
-      !hccSource.includes("} from '../lib/web-http.mjs'") ||
-      !hccSource.includes("import { webIndexHtml } from '../lib/web-ui-template.mjs'") ||
+      !hccSource.includes("} from '../lib/runtime/paths.mjs'") ||
+      !hccSource.includes("} from '../lib/runtime/state.mjs'") ||
+      !hccSource.includes("} from '../lib/project-context.mjs'") ||
+      !hccSource.includes("} from '../lib/handoff.mjs'") ||
+      !hccSource.includes("} from '../lib/core/peers/liveness.mjs'") ||
+      !hccSource.includes("} from '../lib/ui/state-render.mjs'") ||
+      !hccSource.includes("import { createHelpFunctions } from '../lib/ui/help.mjs'") ||
+      !hccSource.includes("import { runtimeRequest } from '../lib/runtime/client.mjs'") ||
+      !hccSource.includes("import { createMessageStore } from '../lib/core/coordination/messages.mjs'") ||
+      !hccSource.includes("import { createTaskStore } from '../lib/core/coordination/tasks.mjs'") ||
+      !hccSource.includes("} from '../lib/task-cli.mjs'") ||
+      !hccSource.includes("} from '../lib/core/sessions/launch.mjs'") ||
+      !hccSource.includes("} from '../lib/integrations/providers.mjs'") ||
+      !hccSource.includes("} from '../lib/core/peers/session.mjs'") ||
+      !hccSource.includes("} from '../lib/core/peers/bindings.mjs'") ||
+      !hccSource.includes("import { createPeerBindingStore } from '../lib/db/stores/peers.mjs'") ||
+      !hccSource.includes("} from '../lib/tmux.mjs'") ||
+      !hccSource.includes("} from '../lib/core/coordination/locks.mjs'") ||
+      !hccSource.includes("} from '../lib/core/coordination/teams.mjs'") ||
+      !hccSource.includes("} from '../lib/integrations/peers/identity.mjs'") ||
+      !hccSource.includes("} from '../lib/runtime/projects.mjs'") ||
+      !hccSource.includes("} from '../lib/web/runtime.mjs'") ||
+      !hccSource.includes("} from '../lib/web/http.mjs'") ||
+      !hccSource.includes("import { webIndexHtml } from '../lib/web/ui-template.mjs'") ||
       !hccSource.includes('const VERSION = PACKAGE_META.version') ||
       !hccSource.includes('writeGuidanceForRoot(ctx.root)')) {
-    fail('CLI still has duplicated package metadata, cli args, DB schema helpers, format helpers, runtime paths, web runtime/HTTP/UI helpers, or guidance wiring');
+    fail('CLI still has duplicated package metadata, cli args, DB schema helpers, CLI runtime helpers, coordination state helpers, format helpers, runtime paths/state helpers, runtime client helpers, project context helpers, handoff helpers, timeline helpers, task liveness helpers, automation helpers, state render helpers, help text helpers, message store helpers, task store helpers, task CLI helpers, session launch helpers, provider command helpers, peer binding helpers, tmux helpers, lock helpers, team planning helpers, peer identity helpers, project registry helpers, web runtime/HTTP/UI helpers, or guidance wiring');
+  }
+  for (const expected of [
+    "renderAutomationContext",
+    "from './core/coordination/automation.mjs'",
+    "formatOpenTaskLine",
+    "from './core/peers/liveness.mjs'",
+    "timelineFromRows",
+    "from './core/coordination/timeline.mjs'",
+    "from './core/coordination/locks.mjs'"
+  ]) {
+    if (!coordinationStateSource.includes(expected)) fail(`coordination state dependency missing: ${expected}`);
   }
   if (hccSource.includes('function createBaseSchema') ||
       hccSource.includes('function runSchemaMigrations') ||
       hccSource.includes('function readSchemaVersion')) {
     fail('CLI still embeds DB schema or migration helpers');
   }
+  for (const helper of [
+    'function createContext(',
+    'function tailFile(',
+    'function commandPath(',
+    'function packageRoot('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds CLI runtime helper: ${helper}`);
+  }
+  if (errorsCompatSource.includes('class CliError')) {
+    fail('errors compatibility module still embeds CliError');
+  }
+  if (!errorsCompatSource.includes("from './shared/errors.mjs'") ||
+      !sharedErrorsSource.includes('class CliError')) {
+    fail('CliError is not wired through lib/shared/errors.mjs');
+  }
+  const oldErrorImportPattern = /from ['"](?:\.\.\/lib\/errors|\.\/errors|\.\.\/errors|\.\.\/\.\.\/errors)\.mjs['"]/;
+  for (const file of ['bin/hcc.mjs', ...libModuleFiles()]) {
+    const source = fs.readFileSync(path.join(repoRoot, file), 'utf8');
+    if (file !== 'lib/errors.mjs' && oldErrorImportPattern.test(source)) {
+      fail(`${file} still imports CliError through the old errors module`);
+    }
+  }
+  const sharedErrors = await import(path.join(repoRoot, 'lib', 'shared', 'errors.mjs'));
+  const compatErrors = await import(path.join(repoRoot, 'lib', 'errors.mjs'));
+  if (typeof sharedErrors.CliError !== 'function') fail('shared errors module missing CliError');
+  if (compatErrors.CliError !== sharedErrors.CliError) fail('errors compatibility export mismatch');
+  if (!hccSource.includes('function shellCommand(args)') ||
+      hccSource.includes('return args.map(shellQuoteArg).join')) {
+    fail('CLI shellCommand wrapper no longer delegates to cli-runtime shellCommand helper');
+  }
+  for (const helper of [
+    'const CLAUDE_SETTINGS_PATH',
+    'const CODEX_HOOKS_PATH',
+    'function installClaudeHooks',
+    'function uninstallClaudeHooks',
+    'function verifyClaudeHooks',
+    'function installCodexHooks',
+    'function uninstallCodexHooks',
+    'function verifyCodexHooks',
+    'function mergeCodexHookEntry',
+    'function mergeHookEntry',
+    'function isHccHookCmd'
+  ]) {
+    if (setupSource.includes(helper)) fail(`setup module still embeds hook helper: ${helper}`);
+  }
+  if (!setupSource.includes("from './integrations/hooks.mjs'")) {
+    fail('setup module does not re-export hook helpers from integrations/hooks.mjs');
+  }
+  for (const helper of [
+    'const SHIM_DIR',
+    'function installShims',
+    'function uninstallShims',
+    'function verifyShims',
+    'function findRealBinary',
+    'function fsExists'
+  ]) {
+    if (setupSource.includes(helper)) fail(`setup module still embeds shim helper: ${helper}`);
+  }
+  if (!setupSource.includes("from './integrations/shims.mjs'")) {
+    fail('setup module does not re-export shim helpers from integrations/shims.mjs');
+  }
+  if (!setupSource.includes("from './shell-path.mjs'")) {
+    fail('setup module does not re-export shell path helpers from shell-path.mjs');
+  }
+  if (!integrationHooksSource.includes("from '../shared/json-file.mjs'") ||
+      !integrationHooksSource.includes("const CLAUDE_SETTINGS_PATH") ||
+      !integrationHooksSource.includes("const CODEX_HOOKS_PATH")) {
+    fail('integrations hook module is missing expected hook storage wiring');
+  }
+  if (!integrationShimsSource.includes("from './shims/script.mjs'") ||
+      !integrationShimsSource.includes("const SHIM_DIR") ||
+      !integrationShimsSource.includes('function findRealBinary') ||
+      !integrationShimsSource.includes("spawnSync('which'")) {
+    fail('integrations shim module is missing expected shim wiring');
+  }
+  if (!shimScriptCompatSource.includes("from './integrations/shims/script.mjs'")) {
+    fail('shim script compatibility module does not re-export from integrations/shims/script.mjs');
+  }
+  if (!integrationShimScriptSource.includes('function generateShim') ||
+      !integrationShimScriptSource.includes('hello-cc shim for ${tool.name}') ||
+      !integrationShimScriptSource.includes('HCC_SHIM_ENSURED')) {
+    fail('integrations shim script module is missing expected generateShim wiring');
+  }
+  if (!shellPathSource.includes('function installPathEntry') ||
+      !shellPathSource.includes('function uninstallPathEntry') ||
+      !shellPathSource.includes('.hcc-shims')) {
+    fail('shell path module is missing expected setup path helpers');
+  }
+  const setupModule = await import(path.join(repoRoot, 'lib', 'setup.mjs'));
+  const integrationHooks = await import(path.join(repoRoot, 'lib', 'integrations', 'hooks.mjs'));
+  const integrationShims = await import(path.join(repoRoot, 'lib', 'integrations', 'shims.mjs'));
+  const integrationShimScript = await import(path.join(repoRoot, 'lib', 'integrations', 'shims', 'script.mjs'));
+  const shimScriptCompat = await import(path.join(repoRoot, 'lib', 'shim-script.mjs'));
+  const shellPath = await import(path.join(repoRoot, 'lib', 'shell-path.mjs'));
+  for (const name of [
+    'installClaudeHooks',
+    'uninstallClaudeHooks',
+    'verifyClaudeHooks',
+    'installCodexHooks',
+    'uninstallCodexHooks',
+    'verifyCodexHooks'
+  ]) {
+    if (typeof integrationHooks[name] !== 'function') fail(`integrations hook module missing export: ${name}`);
+    if (setupModule[name] !== integrationHooks[name]) fail(`setup hook export mismatch: ${name}`);
+  }
+  for (const name of ['installShims', 'uninstallShims', 'verifyShims', 'findRealBinary']) {
+    if (typeof integrationShims[name] !== 'function') fail(`integrations shim module missing export: ${name}`);
+    if (setupModule[name] !== integrationShims[name]) fail(`setup shim export mismatch: ${name}`);
+  }
+  if (typeof integrationShims.SHIM_DIR !== 'string' || !integrationShims.SHIM_DIR.endsWith('.hcc-shims')) {
+    fail(`integrations shim module has unexpected SHIM_DIR: ${integrationShims.SHIM_DIR}`);
+  }
+  if (setupModule.SHIM_DIR !== integrationShims.SHIM_DIR) fail('setup shim dir export mismatch');
+  if (typeof integrationShimScript.generateShim !== 'function') fail('integrations shim script module missing generateShim export');
+  if (shimScriptCompat.generateShim !== integrationShimScript.generateShim) fail('shim script compatibility export mismatch');
+  for (const name of ['installPathEntry', 'uninstallPathEntry']) {
+    if (typeof shellPath[name] !== 'function') fail(`shell path module missing export: ${name}`);
+    if (setupModule[name] !== shellPath[name]) fail(`setup shell path export mismatch: ${name}`);
+  }
+  const cliRuntime = await import(path.join(repoRoot, 'lib', 'cli-runtime.mjs'));
+  for (const name of ['commandPath', 'createContext', 'packageRoot', 'shellCommand', 'tailFile']) {
+    if (typeof cliRuntime[name] !== 'function') fail(`CLI runtime module missing function: ${name}`);
+  }
+  const runtimeCtx = cliRuntime.createContext(
+    { root: '/tmp/project', db: '.hello-cc/test.db', json: true },
+    { cwd: '/tmp/project/subdir', detectRoot: (_cwd, rootHint) => rootHint || '/tmp/project' }
+  );
+  if (runtimeCtx.cwd !== '/tmp/project/subdir' ||
+      runtimeCtx.root !== '/tmp/project' ||
+      !runtimeCtx.dbPath.endsWith('/.hello-cc/test.db') ||
+      runtimeCtx.json !== true ||
+      runtimeCtx.explicitRoot !== true) {
+    fail(`CLI runtime createContext changed: ${JSON.stringify(runtimeCtx)}`);
+  }
+  const quotedCommand = cliRuntime.shellCommand(['alpha', 'two words'], (value) => `[${value}]`);
+  if (quotedCommand !== '[alpha] [two words]') fail(`CLI runtime shellCommand changed: ${quotedCommand}`);
+  const tailPath = path.join(outDir, 'tail-smoke.txt');
+  fs.writeFileSync(tailPath, '0123456789\n');
+  if (cliRuntime.tailFile(tailPath, 4) !== '789' || cliRuntime.tailFile(path.join(outDir, 'missing-tail')) !== '') {
+    fail('CLI runtime tailFile behavior changed');
+  }
+  for (const helper of [
+    'function collectStateSnapshot(',
+    'function buildHookCoordinationContext(',
+    'function ackMessages(',
+    'function statusSummary(',
+    'function statusSnapshot('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds coordination state helper: ${helper}`);
+  }
+  const coordinationState = await import(path.join(repoRoot, 'lib', 'coordination-state.mjs'));
+  if (typeof coordinationState.createCoordinationState !== 'function') {
+    fail('coordination state module missing createCoordinationState');
+  }
+  const stateHelpers = coordinationState.createCoordinationState({
+    connect: () => ({ close() {} }),
+    queryInbox: () => [],
+    queryOpenTasks: () => [],
+    queryTimelineMessages: () => []
+  });
+  for (const name of ['ackMessages', 'buildHookCoordinationContext', 'collectStateSnapshot', 'statusSnapshot', 'statusSummary']) {
+    if (typeof stateHelpers[name] !== 'function') fail(`coordination state factory missing function: ${name}`);
+  }
+  for (const helper of [
+    'function readGlobalRuntimeFile',
+    'function writeGlobalRuntime',
+    'function writeRuntime',
+    'function readRuntime',
+    'function readRuntimeFile',
+    'function probeRuntime',
+    'function readHealthyRuntime',
+    'function readHealthyGlobalRuntime',
+    'function clearRuntime'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds runtime state helper: ${helper}`);
+  }
+  const runtimePaths = await import(path.join(repoRoot, 'lib', 'runtime', 'paths.mjs'));
+  const compatRuntimePaths = await import(path.join(repoRoot, 'lib', 'runtime-paths.mjs'));
+  for (const [moduleName, mod] of [
+    ['runtime/paths', runtimePaths],
+    ['runtime-paths compat', compatRuntimePaths]
+  ]) {
+    for (const name of [
+      'contextForProject',
+      'globalRuntimePath',
+      'globalStateDir',
+      'globalWebTokenPath',
+      'projectDbPath',
+      'projectRegistryPath',
+      'projectStateDir',
+      'runtimePath',
+      'webLogPath'
+    ]) {
+      if (typeof mod[name] !== 'function') fail(`${moduleName} missing export: ${name}`);
+    }
+  }
+  const runtimeState = await import(path.join(repoRoot, 'lib', 'runtime', 'state.mjs'));
+  const compatRuntimeState = await import(path.join(repoRoot, 'lib', 'runtime-state.mjs'));
+  for (const name of [
+    'readGlobalRuntimeFile',
+    'writeGlobalRuntime',
+    'writeRuntime',
+    'readRuntime',
+    'readRuntimeFile',
+    'probeRuntime',
+    'readHealthyRuntime',
+    'readHealthyGlobalRuntime',
+    'clearRuntime'
+  ]) {
+    if (typeof runtimeState[name] !== 'function') fail(`runtime state module missing export: ${name}`);
+    if (typeof compatRuntimeState[name] !== 'function') fail(`runtime state compat module missing export: ${name}`);
+  }
+  const savedRuntimeEnv = {
+    HOME: process.env.HOME,
+    HCC_RUNTIME_URL: process.env.HCC_RUNTIME_URL,
+    HCC_RUNTIME_TOKEN: process.env.HCC_RUNTIME_TOKEN
+  };
+  try {
+    process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-runtime-state-home-'));
+    delete process.env.HCC_RUNTIME_URL;
+    delete process.env.HCC_RUNTIME_TOKEN;
+    const runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-runtime-state-root-'));
+    const runtimeCtx = { root: runtimeRoot };
+
+    const projectRuntimeFile = runtimeState.writeRuntime(runtimeCtx, {
+      base_url: 'http://127.0.0.1:11',
+      token: 'project-token',
+      pid: 101
+    });
+    if (!fs.existsSync(projectRuntimeFile) || (fs.statSync(projectRuntimeFile).mode & 0o777) !== 0o600) {
+      fail('runtime state writeRuntime did not create a 0600 runtime file');
+    }
+    const projectRuntime = runtimeState.readRuntime(runtimeCtx);
+    if (projectRuntime.base_url !== 'http://127.0.0.1:11' ||
+        projectRuntime.token !== 'project-token' ||
+        projectRuntime.source !== projectRuntimeFile) {
+      fail(`runtime state project read changed: ${JSON.stringify(projectRuntime)}`);
+    }
+    if (runtimeState.readRuntimeFile(runtimeCtx)?.token !== 'project-token') {
+      fail('runtime state readRuntimeFile changed');
+    }
+    runtimeState.clearRuntime(runtimeCtx, 202);
+    if (!fs.existsSync(projectRuntimeFile)) fail('runtime state clearRuntime removed a different pid');
+    runtimeState.clearRuntime(runtimeCtx, 101);
+    if (fs.existsSync(projectRuntimeFile)) fail('runtime state clearRuntime did not remove matching project pid');
+
+    const globalRuntimeFile = runtimeState.writeGlobalRuntime({
+      base_url: 'http://127.0.0.1:12',
+      token: 'global-token',
+      pid: 303
+    });
+    const globalRuntime = runtimeState.readRuntime(runtimeCtx);
+    if (globalRuntime.base_url !== 'http://127.0.0.1:12' ||
+        globalRuntime.token !== 'global-token' ||
+        globalRuntime.source !== globalRuntimeFile ||
+        globalRuntime.global !== true) {
+      fail(`runtime state global fallback changed: ${JSON.stringify(globalRuntime)}`);
+    }
+    runtimeState.clearRuntime(runtimeCtx, 404);
+    if (!fs.existsSync(globalRuntimeFile)) fail('runtime state clearRuntime removed a different global pid');
+    runtimeState.clearRuntime(runtimeCtx, 303);
+    if (fs.existsSync(globalRuntimeFile)) fail('runtime state clearRuntime did not remove matching global pid');
+
+    fs.writeFileSync(globalRuntimeFile, '{bad');
+    if (runtimeState.readGlobalRuntimeFile() !== null || fs.existsSync(globalRuntimeFile)) {
+      fail('runtime state readGlobalRuntimeFile did not remove invalid JSON');
+    }
+
+    process.env.HCC_RUNTIME_URL = 'http://env-runtime.test';
+    process.env.HCC_RUNTIME_TOKEN = 'env-token';
+    const envRuntime = runtimeState.readRuntime(runtimeCtx);
+    if (envRuntime.base_url !== 'http://env-runtime.test' ||
+        envRuntime.token !== 'env-token' ||
+        envRuntime.source !== 'env') {
+      fail(`runtime state env runtime precedence changed: ${JSON.stringify(envRuntime)}`);
+    }
+    delete process.env.HCC_RUNTIME_URL;
+    delete process.env.HCC_RUNTIME_TOKEN;
+
+    try {
+      runtimeState.readRuntime(runtimeCtx, { productName: 'product-x', cliName: 'cli-x' });
+      fail('runtime state readRuntime succeeded without runtime');
+    } catch (err) {
+      if (err?.code !== 'RUNTIME_NOT_RUNNING' ||
+          !String(err.message || '').includes('product-x') ||
+          !String(err.message || '').includes('cli-x web')) {
+        throw err;
+      }
+    }
+    if (await runtimeState.probeRuntime(null) !== false ||
+        await runtimeState.readHealthyRuntime(runtimeCtx) !== null ||
+        await runtimeState.readHealthyGlobalRuntime() !== null) {
+      fail('runtime state unhealthy runtime behavior changed');
+    }
+  } finally {
+    for (const [key, value] of Object.entries(savedRuntimeEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+  if (hccSource.includes('async function runtimeRequest')) fail('CLI still embeds runtime request client helper');
+  const runtimeClient = await import(path.join(repoRoot, 'lib', 'runtime', 'client.mjs'));
+  const compatRuntimeClient = await import(path.join(repoRoot, 'lib', 'runtime-client.mjs'));
+  if (typeof runtimeClient.runtimeRequest !== 'function') fail('runtime client module missing runtimeRequest export');
+  if (typeof compatRuntimeClient.runtimeRequest !== 'function') fail('runtime client compat module missing runtimeRequest export');
+  const savedFetch = globalThis.fetch;
+  const runtimeFetchCalls = [];
+  try {
+    globalThis.fetch = async (url, opts = {}) => {
+      runtimeFetchCalls.push({ url, opts });
+      return new Response(JSON.stringify({ ok: true }), { status: 200, headers: { 'content-type': 'application/json' } });
+    };
+    const runtimeClientData = await runtimeClient.runtimeRequest(
+      { root: '/repo-root', dbPath: '/repo-root/.hello-cc/mesh.db' },
+      'POST',
+      '/api/test',
+      { value: 1 },
+      { base_url: 'http://127.0.0.1:8787/', token: 'runtime-token', source: 'runtime-file' },
+      { cliName: 'hccx' }
+    );
+    if (runtimeClientData.ok !== true || runtimeFetchCalls.length !== 1) {
+      fail(`runtime client request data changed: ${JSON.stringify({ runtimeClientData, runtimeFetchCalls })}`);
+    }
+    const call = runtimeFetchCalls[0];
+    if (String(call.url) !== 'http://127.0.0.1:8787/api/test' ||
+        call.opts.method !== 'POST' ||
+        call.opts.headers.Authorization !== 'Bearer runtime-token' ||
+        call.opts.headers['X-HCC-Root'] !== '/repo-root' ||
+        call.opts.headers['X-HCC-DB'] !== '/repo-root/.hello-cc/mesh.db' ||
+        call.opts.body !== JSON.stringify({ value: 1 })) {
+      fail(`runtime client request shape changed: ${JSON.stringify(runtimeFetchCalls, null, 2)}`);
+    }
+    globalThis.fetch = async () => new Response('not-json', { status: 200 });
+    try {
+      await runtimeClient.runtimeRequest(
+        { root: '/repo-root', dbPath: '/repo-root/.hello-cc/mesh.db' },
+        'GET',
+        '/api/bad',
+        null,
+        { base_url: 'http://127.0.0.1:8787/' }
+      );
+      fail('runtime client accepted non-JSON runtime response');
+    } catch (err) {
+      if (err?.code !== 'RUNTIME_BAD_RESPONSE') throw err;
+    }
+    globalThis.fetch = async () => {
+      throw new Error('offline');
+    };
+    try {
+      await runtimeClient.runtimeRequest(
+        { root: '/repo-root', dbPath: '/repo-root/.hello-cc/mesh.db' },
+        'GET',
+        '/api/offline',
+        null,
+        { base_url: 'http://127.0.0.1:8787/', source: 'runtime-file' },
+        { cliName: 'hccx' }
+      );
+      fail('runtime client accepted unreachable runtime');
+    } catch (err) {
+      if (err?.code !== 'RUNTIME_UNREACHABLE' ||
+          !String(err.message || '').includes('Start hccx web again') ||
+          err.extra?.runtime !== 'runtime-file') {
+        throw err;
+      }
+    }
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+  for (const helper of [
+    'function runGit',
+    'function hasHccRootSync',
+    'function detectRoot',
+    'function detectBranch'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds project context helper: ${helper}`);
+  }
+  const projectContext = await import(path.join(repoRoot, 'lib', 'project-context.mjs'));
+  for (const name of [
+    'runGit',
+    'hasHccRootSync',
+    'detectRoot',
+    'detectBranch'
+  ]) {
+    if (typeof projectContext[name] !== 'function') fail(`project context module missing export: ${name}`);
+  }
+  const gitTop = projectContext.runGit(['rev-parse', '--show-toplevel'], repoRoot);
+  if (path.resolve(gitTop || '') !== repoRoot) fail(`project context runGit changed: ${gitTop}`);
+  const gitBranch = projectContext.runGit(['rev-parse', '--abbrev-ref', 'HEAD'], repoRoot) || '';
+  const detectedBranch = projectContext.detectBranch(repoRoot);
+  if (detectedBranch !== gitBranch) {
+    fail(`project context detectBranch changed: ${detectedBranch} != ${gitBranch}`);
+  }
+  const savedHccRoot = process.env.HCC_ROOT;
+  try {
+    delete process.env.HCC_ROOT;
+    if (projectContext.detectRoot('/tmp/hcc-a', '') !== path.resolve('/tmp/hcc-a')) {
+      fail('project context detectRoot cwd fallback changed');
+    }
+    process.env.HCC_ROOT = '/tmp/hcc-env-root';
+    if (projectContext.detectRoot('/tmp/hcc-a', '') !== path.resolve('/tmp/hcc-env-root') ||
+        projectContext.detectRoot('/tmp/hcc-a', '/tmp/hcc-explicit-root') !== path.resolve('/tmp/hcc-explicit-root')) {
+      fail('project context detectRoot precedence changed');
+    }
+  } finally {
+    if (savedHccRoot === undefined) delete process.env.HCC_ROOT;
+    else process.env.HCC_ROOT = savedHccRoot;
+  }
+  const contextRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-project-context-'));
+  fs.mkdirSync(path.join(contextRoot, '.hello-cc'), { recursive: true });
+  if (projectContext.hasHccRootSync(contextRoot)) fail('project context detected root before marker file');
+  fs.writeFileSync(path.join(contextRoot, '.hello-cc', 'config.json'), '{}');
+  if (!projectContext.hasHccRootSync(contextRoot)) fail('project context did not detect config marker');
+  for (const helper of [
+    'function normalizeListText',
+    'function changedFiles'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds handoff helper: ${helper}`);
+  }
+  const handoffModule = await import(path.join(repoRoot, 'lib', 'handoff.mjs'));
+  for (const name of [
+    'normalizeListText',
+    'changedFiles'
+  ]) {
+    if (typeof handoffModule[name] !== 'function') fail(`handoff module missing export: ${name}`);
+  }
+  if (handoffModule.normalizeListText(undefined, ['fallback']) !== JSON.stringify(['fallback'])) {
+    fail('handoff normalizeListText fallback changed');
+  }
+  if (handoffModule.normalizeListText('["kept"]') !== '["kept"]') {
+    fail('handoff normalizeListText JSON passthrough changed');
+  }
+  if (handoffModule.normalizeListText('one, two,, three') !== JSON.stringify(['one', 'two', 'three'])) {
+    fail('handoff normalizeListText CSV parsing changed');
+  }
+  const handoffGitRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-handoff-git-'));
+  run('git', ['init'], { cwd: handoffGitRoot });
+  run('git', ['config', 'user.email', 'hcc-regression@example.invalid'], { cwd: handoffGitRoot });
+  run('git', ['config', 'user.name', 'hcc regression'], { cwd: handoffGitRoot });
+  fs.writeFileSync(path.join(handoffGitRoot, 'tracked.txt'), 'base\n');
+  run('git', ['add', 'tracked.txt'], { cwd: handoffGitRoot });
+  run('git', ['commit', '-m', 'init'], { cwd: handoffGitRoot });
+  fs.writeFileSync(path.join(handoffGitRoot, 'tracked.txt'), 'changed\n');
+  fs.writeFileSync(path.join(handoffGitRoot, 'staged.txt'), 'new\n');
+  run('git', ['add', 'staged.txt'], { cwd: handoffGitRoot });
+  const handoffChanged = handoffModule.changedFiles(handoffGitRoot);
+  if (JSON.stringify(handoffChanged) !== JSON.stringify(['staged.txt', 'tracked.txt'])) {
+    fail(`handoff changedFiles changed: ${JSON.stringify(handoffChanged)}`);
+  }
+  for (const helper of [
+    'function parseEventPayload',
+    'function uniqueList',
+    'function messageParticipants',
+    'function taskParticipants',
+    'function payloadParticipants',
+    'function peerMatchesTimelineItem',
+    'function shouldHideTimelineMessage',
+    'function shouldHideTimelineEvent',
+    'function timelineDirection',
+    'function timelineFromRows'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds timeline helper: ${helper}`);
+  }
+  if (hccSource.includes('const TIMELINE_EVENT_ALLOW')) fail('CLI still embeds timeline event allow list');
+  const timelineModule = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'timeline.mjs'));
+  const compatTimelineModule = await import(path.join(repoRoot, 'lib', 'timeline.mjs'));
+  for (const name of [
+    'parseEventPayload',
+    'uniqueList',
+    'messageParticipants',
+    'taskParticipants',
+    'payloadParticipants',
+    'peerMatchesTimelineItem',
+    'shouldHideTimelineMessage',
+    'shouldHideTimelineEvent',
+    'timelineDirection',
+    'timelineFromRows'
+  ]) {
+    if (typeof timelineModule[name] !== 'function') fail(`timeline module missing export: ${name}`);
+    if (typeof compatTimelineModule[name] !== 'function') fail(`timeline compat module missing export: ${name}`);
+  }
+  if (JSON.stringify(timelineModule.uniqueList(['a', '', null, 'a', 7])) !== JSON.stringify(['a', '7'])) {
+    fail('timeline uniqueList behavior changed');
+  }
+  if (JSON.stringify(timelineModule.parseEventPayload({ payload: '{bad' })) !== JSON.stringify({})) {
+    fail('timeline parseEventPayload invalid JSON behavior changed');
+  }
+  if (!timelineModule.shouldHideTimelineMessage({ kind: 'task', body: 'Task #12 assigned: do work' }) ||
+      !timelineModule.shouldHideTimelineEvent({ type: 'message.sent' }) ||
+      timelineModule.shouldHideTimelineEvent({ type: 'task.done' })) {
+    fail('timeline hide filters changed');
+  }
+  const timelineItems = timelineModule.timelineFromRows({
+    messages: [
+      { id: 1, sender: 'system', recipient: 'peer-b', task_id: 1, kind: 'task', body: 'Task #1 assigned: hidden', created_at: 1, read_at: null },
+      { id: 2, sender: 'peer-a', recipient: 'peer-b', task_id: 2, kind: 'note', body: 'hello timeline', created_at: 2, read_at: null },
+      { id: 3, sender: 'peer-b', recipient: 'all', task_id: null, kind: 'note', body: 'broadcast timeline', created_at: 3, read_at: 3 }
+    ],
+    handoffs: [
+      { id: 4, from_peer: 'peer-a', to_peer: 'peer-b', task_id: 2, summary: 'handoff summary', created_at: 4, tests: 'tests', risks: 'risks' }
+    ],
+    tasks: [
+      { id: 5, status: 'running', created_by: 'human', owner: 'peer-b', assignee: '', title: 'task title', created_at: 5, updated_at: 5, parent_id: null }
+    ],
+    locks: [
+      { resource: 'bin/hcc.mjs', base_resource: 'bin/hcc.mjs', scope: 'timeline', owner: 'peer-a', task_id: 2, reason: 'hidden from peer-b', created_at: 6 }
+    ],
+    events: [
+      { id: 7, type: 'message.sent', actor: 'peer-a', task_id: 2, payload: '{}', created_at: 7 },
+      { id: 8, type: 'task.done', actor: 'peer-a', task_id: 2, payload: JSON.stringify({ owner: 'peer-b', summary: 'done summary' }), created_at: 8 }
+    ]
+  }, 'peer-b');
+  const timelineIds = timelineItems.map((item) => item.id);
+  if (JSON.stringify(timelineIds) !== JSON.stringify(['message:2', 'message:3', 'handoff:4', 'task:5', 'event:8'])) {
+    fail(`timelineFromRows filtering/order changed: ${JSON.stringify(timelineItems)}`);
+  }
+  const inbound = timelineItems.find((item) => item.id === 'message:2');
+  const broadcast = timelineItems.find((item) => item.id === 'message:3');
+  if (inbound?.direction !== 'in' || inbound?.unread !== true ||
+      broadcast?.direction !== 'out' || broadcast?.broadcast !== true) {
+    fail(`timelineFromRows message metadata changed: ${JSON.stringify(timelineItems)}`);
+  }
+  for (const helper of [
+    'function taskRelatedLocks',
+    'function taskOwnerLiveness',
+    'function annotateTasksWithLiveness',
+    'function taskOwnerStateText',
+    'function summarizeTask',
+    'function formatOpenTaskLine'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds task liveness helper: ${helper}`);
+  }
+  const taskLivenessModule = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'liveness.mjs'));
+  const compatTaskLivenessModule = await import(path.join(repoRoot, 'lib', 'task-liveness.mjs'));
+  for (const name of [
+    'taskRelatedLocks',
+    'taskOwnerLiveness',
+    'annotateTasksWithLiveness',
+    'taskOwnerStateText',
+    'summarizeTask',
+    'formatOpenTaskLine'
+  ]) {
+    if (typeof taskLivenessModule[name] !== 'function') fail(`task liveness module missing export: ${name}`);
+    if (typeof compatTaskLivenessModule[name] !== 'function') fail(`task liveness compat module missing export: ${name}`);
+  }
+  const livenessTasks = taskLivenessModule.annotateTasksWithLiveness([
+    { id: 1, status: 'running', owner: 'active-owner', assignee: '', title: 'Active task', priority: 1 },
+    { id: 2, status: 'running', owner: 'stale-owner', assignee: '', title: 'Stale task', priority: 2 },
+    { id: 3, status: 'running', owner: 'locked-owner', assignee: '', title: 'Locked task', priority: 3 },
+    { id: 4, status: 'pending', owner: 'stale-pending-owner', assignee: '', title: 'Pending stale task', priority: 4 },
+    { id: 5, status: 'pending', owner: '', assignee: 'worker', title: 'Unowned task', priority: 5 }
+  ], [
+    { id: 'active-owner', age_sec: 10 },
+    { id: 'stale-owner', last_seen_at: 100 },
+    { id: 'locked-owner', age_sec: 900 },
+    { id: 'stale-pending-owner', age_sec: 900 }
+  ], [
+    { owner: 'locked-owner', task_id: 3 }
+  ], 1000, 600);
+  const activeTask = livenessTasks.find((task) => task.id === 1);
+  const staleTask = livenessTasks.find((task) => task.id === 2);
+  const lockedTask = livenessTasks.find((task) => task.id === 3);
+  const pendingTask = livenessTasks.find((task) => task.id === 4);
+  const unownedTask = livenessTasks.find((task) => task.id === 5);
+  if (!activeTask.owner_active || activeTask.owner_stale || taskLivenessModule.taskOwnerStateText(activeTask) !== 'active') {
+    fail(`task liveness active owner changed: ${JSON.stringify(activeTask)}`);
+  }
+  if (!staleTask.owner_stale || !staleTask.takeover_ready || staleTask.owner_age_sec !== 900 ||
+      taskLivenessModule.taskOwnerStateText(staleTask) !== 'stale/no-lock') {
+    fail(`task liveness stale takeover changed: ${JSON.stringify(staleTask)}`);
+  }
+  if (!lockedTask.owner_stale || lockedTask.takeover_ready || lockedTask.related_lock_count !== 1 ||
+      taskLivenessModule.taskOwnerStateText(lockedTask) !== 'stale/locks=1') {
+    fail(`task liveness stale locked owner changed: ${JSON.stringify(lockedTask)}`);
+  }
+  if (!pendingTask.owner_stale || pendingTask.takeover_ready) {
+    fail(`task liveness pending takeover changed: ${JSON.stringify(pendingTask)}`);
+  }
+  if (unownedTask.owner_known || unownedTask.owner_active !== null || unownedTask.owner_stale || unownedTask.takeover_ready) {
+    fail(`task liveness unowned task changed: ${JSON.stringify(unownedTask)}`);
+  }
+  const summary = taskLivenessModule.summarizeTask(staleTask);
+  if (!summary.takeover_ready || summary.owner_age_sec !== 900 || summary.related_lock_count !== 0) {
+    fail(`task liveness summarizeTask changed: ${JSON.stringify(summary)}`);
+  }
+  if (taskLivenessModule.formatOpenTaskLine(staleTask) !== '#2 running owner=stale-owner owner_state=stale/no-lock: Stale task') {
+    fail(`task liveness formatOpenTaskLine changed: ${taskLivenessModule.formatOpenTaskLine(staleTask)}`);
+  }
+  for (const helper of [
+    'function actionCommand',
+    'function makeAction',
+    'function looksLikeMultiTask',
+    'function selectCurrentTask',
+    'function deriveAutomation',
+    'function renderAutomationContext'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds automation helper: ${helper}`);
+  }
+  const automationModule = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'automation.mjs'));
+  const compatAutomationModule = await import(path.join(repoRoot, 'lib', 'automation.mjs'));
+  for (const name of [
+    'actionCommand',
+    'makeAction',
+    'looksLikeMultiTask',
+    'selectCurrentTask',
+    'deriveAutomation',
+    'renderAutomationContext'
+  ]) {
+    if (typeof automationModule[name] !== 'function') fail(`automation module missing export: ${name}`);
+    if (typeof compatAutomationModule[name] !== 'function') fail(`automation compat module missing export: ${name}`);
+  }
+  if (!automationModule.looksLikeMultiTask({ title: 'split', body: '- one\n- two' })) {
+    fail('automation looksLikeMultiTask bullet detection changed');
+  }
+  const selectedTask = automationModule.selectCurrentTask([
+    { id: 2, status: 'claimed', owner: 'peer-a', priority: 1 },
+    { id: 1, status: 'running', owner: 'peer-a', priority: 9 }
+  ], 'peer-a');
+  if (selectedTask?.id !== 1) fail(`automation selectCurrentTask ranking changed: ${JSON.stringify(selectedTask)}`);
+  const automationConfig = { cliName: 'hccx', activePeerTtl: 600, defaultLockTtl: 321 };
+  const automationSnapshot = {
+    now: 1000,
+    active_peer_ttl: 600,
+    peers: [
+      { id: 'peer-a', age_sec: 10 },
+      { id: 'other-peer', age_sec: 20 }
+    ],
+    tasks: [
+      { id: 10, status: 'running', owner: 'peer-a', assignee: '', title: 'Main task', priority: 1, parent_id: null }
+    ],
+    locks: [],
+    messages: []
+  };
+  const acquireAutomation = automationModule.deriveAutomation(
+    automationSnapshot,
+    'peer-a',
+    { resource: 'bin/hcc.mjs', scope: 'automation' },
+    automationConfig
+  );
+  if (acquireAutomation.phase !== 'acquire_lock' ||
+      acquireAutomation.next_action.kind !== 'lock.acquire' ||
+      !acquireAutomation.next_action.argv.includes('321') ||
+      !String(acquireAutomation.next_action.command || '').startsWith('hccx lock acquire')) {
+    fail(`automation lock acquire action changed: ${JSON.stringify(acquireAutomation, null, 2)}`);
+  }
+  const finishAutomation = automationModule.deriveAutomation(
+    automationSnapshot,
+    'peer-a',
+    { intent: 'finish' },
+    automationConfig
+  );
+  if (finishAutomation.phase !== 'handoff' || finishAutomation.next_action.kind !== 'handoff.create') {
+    fail(`automation finish action changed: ${JSON.stringify(finishAutomation, null, 2)}`);
+  }
+  const claimAutomation = automationModule.deriveAutomation({
+    ...automationSnapshot,
+    tasks: [
+      { id: 11, status: 'pending', owner: '', assignee: 'peer-a', title: 'Assigned task', priority: 1 }
+    ]
+  }, 'peer-a', {}, automationConfig);
+  if (claimAutomation.phase !== 'claim_task' ||
+      claimAutomation.next_action.kind !== 'task.claim' ||
+      claimAutomation.next_action.task_id !== 11) {
+    fail(`automation assigned claim action changed: ${JSON.stringify(claimAutomation, null, 2)}`);
+  }
+  const conflictAutomation = automationModule.deriveAutomation({
+    ...automationSnapshot,
+    locks: [
+      { resource: 'scoped:runtime', base_resource: 'bin/hcc.mjs', scope: 'automation', owner: 'other-peer', task_id: 99, expires_at: 1200 }
+    ]
+  }, 'peer-a', { resource: 'bin/hcc.mjs', scope: 'automation' }, automationConfig);
+  if (conflictAutomation.phase !== 'coordinate_lock' ||
+      conflictAutomation.next_action.kind !== 'msg.send' ||
+      conflictAutomation.next_action.lock_owner !== 'other-peer') {
+    fail(`automation lock conflict action changed: ${JSON.stringify(conflictAutomation, null, 2)}`);
+  }
+  const automationContext = automationModule.renderAutomationContext(acquireAutomation);
+  if (!automationContext.includes('phase: acquire_lock') ||
+      !automationContext.includes('why: task #10 needs bin/hcc.mjs [automation] lock')) {
+    fail(`automation render context changed: ${automationContext}`);
+  }
+  for (const helper of [
+    'function renderStatusSummary',
+    'function normalizeStateResources',
+    'function renderStateSummary'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds state render helper: ${helper}`);
+  }
+  const stateRender = await import(path.join(repoRoot, 'lib', 'ui', 'state-render.mjs'));
+  const compatStateRender = await import(path.join(repoRoot, 'lib', 'state-render.mjs'));
+  for (const name of [
+    'renderStatusSummary',
+    'normalizeStateResources',
+    'renderStateSummary'
+  ]) {
+    if (typeof stateRender[name] !== 'function') fail(`state render module missing export: ${name}`);
+    if (typeof compatStateRender[name] !== 'function') fail(`state render compat module missing export: ${name}`);
+  }
+  const normalizedResources = stateRender.normalizeStateResources(['bin/hcc.mjs,scripts/regression.mjs', 'bin/hcc.mjs', '', null]);
+  if (JSON.stringify(normalizedResources) !== JSON.stringify(['bin/hcc.mjs', 'scripts/regression.mjs'])) {
+    fail(`state resource normalization changed: ${JSON.stringify(normalizedResources)}`);
+  }
+  const renderedStatus = stateRender.renderStatusSummary({
+    root: '/repo',
+    db: '/repo/.hello-cc/mesh.db',
+    active_peers: 2,
+    stale_peers: 3,
+    tasks: [
+      { status: 'done', n: 4 },
+      { status: 'running', n: 1 }
+    ],
+    active_locks: 5,
+    unread: 6,
+    recent_events: [
+      { id: 7, type: 'task.done', actor: 'peer-a', task_id: 8, created_at: 9 }
+    ]
+  }, 'peer-a');
+  if (!renderedStatus.includes('peers: active=2, stale=3') ||
+      !renderedStatus.includes('tasks: done:4, running:1') ||
+      !renderedStatus.includes('inbox(peer-a): unread=6') ||
+      !renderedStatus.includes('1970-01-01T00:00:09.000Z')) {
+    fail(`state render status output changed:\n${renderedStatus}`);
+  }
+  const renderedState = stateRender.renderStateSummary({
+    root: '/repo',
+    automation: {
+      current_task: { id: 10, status: 'running', title: 'State task' },
+      phase: 'work',
+      next_action: { kind: 'none', command: '', reason: 'continue task #10' },
+      finish_actions: [{ command: 'hcc handoff create' }],
+      warnings: ['review locks before commit']
+    },
+    timeline: [
+      { ts: 11, source: 'message', source_id: 12, title: 'note', text: 'body' }
+    ]
+  }, 'peer-a');
+  if (!renderedState.includes('current task: #10 running State task') ||
+      !renderedState.includes('next: none') ||
+      !renderedState.includes('- hcc handoff create') ||
+      !renderedState.includes('review locks before commit') ||
+      !renderedState.includes('message:12 note')) {
+    fail(`state render state output changed:\n${renderedState}`);
+  }
+  for (const helper of [
+    'function helpMain',
+    'function helpTask',
+    'function helpTeam',
+    'function helpState',
+    'function helpJoin',
+    'function helpEnv',
+    'function helpMsg',
+    'function helpAsk',
+    'function helpBroadcast',
+    'function helpInject',
+    'function helpPeer',
+    'function helpLock',
+    'function helpHandoff',
+    'function helpEvent',
+    'function helpRun',
+    'function helpUp',
+    'function helpDown',
+    'function helpUpdate',
+    'function helpUninstall',
+    'function helpWeb'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds help text helper: ${helper}`);
+  }
+  const helpModule = await import(path.join(repoRoot, 'lib', 'ui', 'help.mjs'));
+  const compatHelpModule = await import(path.join(repoRoot, 'lib', 'help.mjs'));
+  if (typeof helpModule.createHelpFunctions !== 'function') fail('help module missing createHelpFunctions export');
+  if (typeof compatHelpModule.createHelpFunctions !== 'function') fail('help compat module missing createHelpFunctions export');
+  const capturedHelp = [];
+  const savedConsoleLog = console.log;
+  try {
+    console.log = (value = '') => capturedHelp.push(String(value));
+    const helpFns = helpModule.createHelpFunctions({
+      productName: 'product-x',
+      version: '1.2.3',
+      cliName: 'hccx',
+      npmPackageName: '@scope/pkg-x'
+    });
+    for (const name of [
+      'helpMain',
+      'helpTask',
+      'helpTeam',
+      'helpState',
+      'helpJoin',
+      'helpEnv',
+      'helpMsg',
+      'helpAsk',
+      'helpBroadcast',
+      'helpInject',
+      'helpPeer',
+      'helpLock',
+      'helpHandoff',
+      'helpEvent',
+      'helpRun',
+      'helpUp',
+      'helpDown',
+      'helpUpdate',
+      'helpUninstall',
+      'helpWeb'
+    ]) {
+      if (typeof helpFns[name] !== 'function') fail(`help factory missing function: ${name}`);
+    }
+    helpFns.helpMain();
+    helpFns.helpUpdate();
+    helpFns.helpUninstall();
+    helpFns.helpWeb();
+  } finally {
+    console.log = savedConsoleLog;
+  }
+  const [factoryMainHelp, factoryUpdateHelp, factoryUninstallHelp, factoryWebHelp] = capturedHelp;
+  if (!factoryMainHelp?.startsWith('product-x 1.2.3') ||
+      !factoryMainHelp.includes('hccx [--root DIR]') ||
+      !factoryUpdateHelp?.includes('npm install -g @scope/pkg-x@TAG') ||
+      !factoryUninstallHelp?.includes('hccx uninstall [--purge --yes]') ||
+      !factoryWebHelp?.includes("HCC_WEB_TOKEN='long-token' hccx web --port 8787")) {
+    fail(`help factory output changed:\n${capturedHelp.join('\n---\n')}`);
+  }
+  for (const helper of [
+    'function sendMessage(',
+    'function queryInbox(',
+    'function queryTimelineMessages(',
+    'function getMessage(',
+    'function queryMessageThread(',
+    'function ackMessage('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds message store helper: ${helper}`);
+  }
+  const messagesModule = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'messages.mjs'));
+  const compatMessagesModule = await import(path.join(repoRoot, 'lib', 'messages.mjs'));
+  if (typeof messagesModule.createMessageStore !== 'function') fail('messages module missing createMessageStore export');
+  if (typeof compatMessagesModule.createMessageStore !== 'function') fail('messages compat module missing createMessageStore export');
+  const messageEvents = [];
+  const messageStore = messagesModule.createMessageStore({
+    now: () => 1234,
+    addEvent: (_db, type, actor, taskId, payload) => messageEvents.push({ type, actor, taskId, payload })
+  });
+  for (const name of [
+    'ackMessage',
+    'getMessage',
+    'queryInbox',
+    'queryMessageThread',
+    'queryTimelineMessages',
+    'sendMessage'
+  ]) {
+    if (typeof messageStore[name] !== 'function') fail(`message store missing function: ${name}`);
+  }
+  const messageDb = new DatabaseSync(':memory:');
+  try {
+    messageDb.exec(`
+      CREATE TABLE messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        sender TEXT NOT NULL,
+        recipient TEXT,
+        task_id INTEGER,
+        kind TEXT NOT NULL DEFAULT 'note',
+        body TEXT NOT NULL,
+        reply_to INTEGER,
+        thread_id INTEGER,
+        created_at INTEGER NOT NULL
+      );
+      CREATE TABLE message_reads (
+        message_id INTEGER NOT NULL,
+        peer TEXT NOT NULL,
+        read_at INTEGER NOT NULL,
+        PRIMARY KEY (message_id, peer)
+      );
+    `);
+    const firstId = messageStore.sendMessage(messageDb, 'alice', 'bob', 42, 'note', 'hello');
+    const replyId = messageStore.sendMessage(messageDb, 'bob', 'alice', 42, 'reply', 'ack', {
+      reply_to: firstId,
+      thread_id: firstId
+    });
+    const inbox = messageStore.queryInbox(messageDb, 'bob', false, 10);
+    const thread = messageStore.queryMessageThread(messageDb, replyId, 10);
+    messageStore.ackMessage(messageDb, 'bob', inbox[0]);
+    const unread = messageStore.queryInbox(messageDb, 'bob', false, 10);
+    const timeline = messageStore.queryTimelineMessages(messageDb, 'bob', 10);
+    if (firstId !== 1 ||
+        replyId !== 2 ||
+        inbox.length !== 1 ||
+        inbox[0].thread_id !== firstId ||
+        thread.thread_id !== firstId ||
+        thread.messages.length !== 2 ||
+        unread.length !== 0 ||
+        timeline.length !== 2 ||
+        messageEvents.map((event) => event.type).join(',') !== 'message.sent,message.sent,message.ack') {
+      fail('message store smoke test changed expected send/inbox/thread/ack behavior');
+    }
+  } finally {
+    messageDb.close();
+  }
+  for (const helper of [
+    'function claimTaskRowsForPeer(',
+    'function takeoverPolicyDetails(',
+    'function takeOverTaskForPeer(',
+    'function queryOpenTasks(',
+    'function taskById(',
+    'function teamChildren(',
+    'function teamSummary(',
+    'function claimNextTasksForPeer('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds task store helper: ${helper}`);
+  }
+  const taskStoreModule = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'tasks.mjs'));
+  const compatTaskStoreModule = await import(path.join(repoRoot, 'lib', 'task-store.mjs'));
+  if (typeof taskStoreModule.createTaskStore !== 'function') fail('task store module missing createTaskStore export');
+  if (typeof compatTaskStoreModule.createTaskStore !== 'function') fail('task store compat module missing createTaskStore export');
+  const taskEvents = [];
+  const taskMessages = [];
+  const taskStore = taskStoreModule.createTaskStore({
+    now: () => 2000,
+    activePeerTtl: 60,
+    addEvent: (_db, type, actor, taskId, payload) => taskEvents.push({ type, actor, taskId, payload }),
+    sendMessage: (_db, sender, recipient, taskId, kind, body) => {
+      taskMessages.push({ sender, recipient, taskId, kind, body });
+      return taskMessages.length;
+    }
+  });
+  for (const name of [
+    'claimNextTasksForPeer',
+    'claimTaskRowsForPeer',
+    'queryOpenTasks',
+    'takeOverTaskForPeer',
+    'taskById',
+    'teamChildren',
+    'teamSummary',
+    'takeoverPolicyDetails'
+  ]) {
+    if (typeof taskStore[name] !== 'function') fail(`task store missing function: ${name}`);
+  }
+  const taskDb = new DatabaseSync(':memory:');
+  try {
+    taskDb.exec(`
+      CREATE TABLE tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        title TEXT NOT NULL,
+        body TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        assignee TEXT,
+        owner TEXT,
+        parent_id INTEGER,
+        team_role TEXT,
+        priority INTEGER NOT NULL DEFAULT 100,
+        created_by TEXT,
+        claimed_at INTEGER,
+        completed_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE peers (
+        id TEXT PRIMARY KEY,
+        last_seen_at INTEGER NOT NULL
+      );
+      CREATE TABLE handoffs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id INTEGER,
+        summary TEXT
+      );
+    `);
+    taskDb.prepare(`
+      INSERT INTO tasks(title, status, assignee, owner, parent_id, team_role, priority, created_by, created_at, updated_at)
+      VALUES
+        ('assigned pending', 'pending', 'bob', NULL, NULL, NULL, 10, 'alice', 1000, 1000),
+        ('stale owned', 'running', NULL, 'old-owner', NULL, NULL, 20, 'alice', 1000, 1000),
+        ('parent', 'pending', NULL, NULL, NULL, NULL, 30, 'alice', 1000, 1000),
+        ('child done', 'done', NULL, NULL, 3, 'worker', 31, 'alice', 1000, 1000),
+        ('next pending', 'pending', NULL, NULL, NULL, NULL, 40, 'alice', 1000, 1000)
+    `).run();
+    taskDb.prepare('INSERT INTO peers(id, last_seen_at) VALUES (?, ?)').run('old-owner', 1000);
+    taskDb.prepare('INSERT INTO handoffs(task_id, summary) VALUES (?, ?)').run(4, 'child handoff');
+    const claimed = taskStore.claimTaskRowsForPeer(taskDb, 'bob', [1]);
+    const blockedReject = (() => {
+      try {
+        taskStore.takeOverTaskForPeer(taskDb, 'taker', 2, { reason: 'blocked policy', policy: 'blocked' });
+        return false;
+      } catch (err) {
+        return err?.code === 'TAKEOVER_POLICY';
+      }
+    })();
+    const taken = taskStore.takeOverTaskForPeer(taskDb, 'taker', 2, { reason: 'stale policy', policy: 'stale', staleAfter: 60 });
+    const next = taskStore.claimNextTasksForPeer(taskDb, 'next-peer', { count: 1 });
+    const openForBob = taskStore.queryOpenTasks(taskDb, 10, 'bob');
+    const summary = taskStore.teamSummary(taskDb, 3);
+    if (claimed.length !== 1 ||
+        claimed[0].owner !== 'bob' ||
+        !blockedReject ||
+        taken.owner !== 'taker' ||
+        taskMessages.length !== 1 ||
+        !taskMessages[0].body.includes('Task #2 taken over by taker') ||
+        next.tasks.length !== 1 ||
+        next.tasks[0].owner !== 'next-peer' ||
+        openForBob.length !== 1 ||
+        summary.children.length !== 1 ||
+        summary.counts.done !== 1 ||
+        taskEvents.map((event) => event.type).join(',') !== 'task.claimed,task.takeover,task.claimed') {
+      fail('task store smoke test changed expected claim/takeover/next/team behavior');
+    }
+  } finally {
+    taskDb.close();
+  }
+  for (const helper of [
+    'function parseTaskIds(',
+    'function positiveIntOpt(',
+    'function taskRowsText('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds task CLI helper: ${helper}`);
+  }
+  const taskCliModule = await import(path.join(repoRoot, 'lib', 'task-cli.mjs'));
+  for (const name of ['parseTaskIds', 'positiveIntOpt', 'taskRowsText']) {
+    if (typeof taskCliModule[name] !== 'function') fail(`task CLI module missing function: ${name}`);
+  }
+  const parsedTaskIds = taskCliModule.parseTaskIds({
+    id: ['1,2', '2'],
+    ids: '3',
+    _: ['4']
+  });
+  if (parsedTaskIds.join(',') !== '1,2,3,4') {
+    fail(`task CLI parseTaskIds changed expected id normalization: ${parsedTaskIds.join(',')}`);
+  }
+  const parseRejects = (() => {
+    try {
+      taskCliModule.parseTaskIds({ id: 'bad' });
+      return false;
+    } catch (err) {
+      return err?.code === 'BAD_ARGS';
+    }
+  })();
+  const emptyRejects = (() => {
+    try {
+      taskCliModule.parseTaskIds({});
+      return false;
+    } catch (err) {
+      return err?.code === 'BAD_ARGS';
+    }
+  })();
+  const lowRejects = (() => {
+    try {
+      taskCliModule.positiveIntOpt({ count: '0' }, 'count', 1, { max: 5 });
+      return false;
+    } catch (err) {
+      return err?.code === 'BAD_ARGS';
+    }
+  })();
+  const highRejects = (() => {
+    try {
+      taskCliModule.positiveIntOpt({ count: '6' }, 'count', 1, { max: 5 });
+      return false;
+    } catch (err) {
+      return err?.code === 'BAD_ARGS';
+    }
+  })();
+  if (!parseRejects ||
+      !emptyRejects ||
+      !lowRejects ||
+      !highRejects ||
+      taskCliModule.positiveIntOpt({ count: '2' }, 'count', 1, { max: 5 }) !== 2 ||
+      taskCliModule.taskRowsText([], 'claimed') !== 'no pending task' ||
+      taskCliModule.taskRowsText([{ id: 7, title: 'demo' }], 'claimed') !== 'claimed task #7: demo') {
+    fail('task CLI smoke test changed expected parse/count/render behavior');
+  }
+  for (const helper of [
+    'const WEB_CHILD_ENV',
+    'const LAUNCH_FINGERPRINT_ENV',
+    'const PROVIDER_STATE_ENV',
+    'const LAUNCH_ENV_IGNORED_KEYS',
+    'function childSessionEnv',
+    'function launchEnvironmentFingerprint',
+    'function launchFingerprint',
+    'function isLikelyShellCommand',
+    'function isProviderFallbackWrapper',
+    'function isRelaunchableProviderSession',
+    'function tmuxProviderState',
+    'function tmuxManagedSessionName',
+    'function tmuxEnvironmentArgs',
+    'function isolatedEnvCommandArgs'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds session launch helper: ${helper}`);
+  }
+  const sessionLaunchSource = fs.readFileSync(path.join(repoRoot, 'lib', 'core', 'sessions', 'launch.mjs'), 'utf8');
+  const compatSessionLaunchSource = fs.readFileSync(path.join(repoRoot, 'lib', 'session-launch.mjs'), 'utf8');
+  if (sessionLaunchSource.includes("from '../../terminal/") ||
+      sessionLaunchSource.includes("from '../terminal/") ||
+      sessionLaunchSource.includes('tmuxSessionEnvironmentValue')) {
+    fail('core session launch module depends on terminal/tmux helpers');
+  }
+  if (!compatSessionLaunchSource.includes("from './core/sessions/launch.mjs'") ||
+      !compatSessionLaunchSource.includes("from './terminal/tmux.mjs'")) {
+    fail('session launch compatibility module does not re-export from the new boundaries');
+  }
+  const sessionLaunch = await import(path.join(repoRoot, 'lib', 'core', 'sessions', 'launch.mjs'));
+  const compatSessionLaunch = await import(path.join(repoRoot, 'lib', 'session-launch.mjs'));
+  const tmuxModuleForSessionLaunch = await import(path.join(repoRoot, 'lib', 'tmux.mjs'));
+  for (const name of [
+    'childSessionEnv',
+    'launchEnvironmentFingerprint',
+    'launchFingerprint',
+    'isLikelyShellCommand',
+    'isProviderFallbackWrapper',
+    'isRelaunchableProviderSession',
+    'isolatedEnvCommandArgs'
+  ]) {
+    if (typeof sessionLaunch[name] !== 'function') fail(`session launch module missing export: ${name}`);
+    if (compatSessionLaunch[name] !== sessionLaunch[name]) fail(`session launch compat export mismatch: ${name}`);
+  }
+  for (const name of [
+    'tmuxProviderState',
+    'tmuxManagedSessionName',
+    'tmuxEnvironmentArgs'
+  ]) {
+    if (typeof tmuxModuleForSessionLaunch[name] !== 'function') fail(`tmux module missing session launch adapter: ${name}`);
+    if (compatSessionLaunch[name] !== tmuxModuleForSessionLaunch[name]) {
+      fail(`session launch compat terminal export mismatch: ${name}`);
+    }
+  }
+  if (sessionLaunch.WEB_CHILD_ENV !== 'HCC_WEB_CHILD' ||
+      sessionLaunch.LAUNCH_FINGERPRINT_ENV !== 'HCC_LAUNCH_FINGERPRINT' ||
+      sessionLaunch.PROVIDER_STATE_ENV !== 'HCC_PROVIDER_STATE') {
+    fail('session launch env constant changed');
+  }
+  const childEnv = sessionLaunch.childSessionEnv({ EXTRA: '1' }, { HCC_WEB_CHILD: '1', BASE: '2' });
+  if (childEnv.HCC_WEB_CHILD !== undefined || childEnv.BASE !== '2' || childEnv.EXTRA !== '1') {
+    fail(`session launch childSessionEnv changed: ${JSON.stringify(childEnv)}`);
+  }
+  const launchEnvA = sessionLaunch.launchEnvironmentFingerprint({
+    B: '2',
+    A: '1',
+    PWD: '/ignored',
+    TMUX: 'ignored',
+    HCC_PEER: 'ignored'
+  });
+  const launchEnvB = sessionLaunch.launchEnvironmentFingerprint({ A: '1', B: '2' });
+  const launchEnvC = sessionLaunch.launchEnvironmentFingerprint({ A: '1', B: '3' });
+  if (launchEnvA !== launchEnvB || launchEnvA === launchEnvC) {
+    fail('session launch environment fingerprint filtering/sorting changed');
+  }
+  const launchFingerprintA = sessionLaunch.launchFingerprint({ command: 'cmd', cwd: '/tmp/a', env: { A: '1' } });
+  const launchFingerprintB = sessionLaunch.launchFingerprint({ command: 'cmd', cwd: '/tmp/b', env: { A: '1' } });
+  if (launchFingerprintA === launchFingerprintB) {
+    fail('session launch fingerprint no longer includes cwd');
+  }
+  if (!sessionLaunch.isLikelyShellCommand('/bin/bash') ||
+      !sessionLaunch.isLikelyShellCommand('-zsh') ||
+      sessionLaunch.isLikelyShellCommand('node')) {
+    fail('session launch shell command detection changed');
+  }
+  if (!sessionLaunch.isProviderFallbackWrapper(`${sessionLaunch.PROVIDER_STATE_ENV}=starting exec bash`) ||
+      !sessionLaunch.isProviderFallbackWrapper('exec zsh') ||
+      sessionLaunch.isProviderFallbackWrapper('node script.js')) {
+    fail('session launch provider fallback detection changed');
+  }
+  if (!sessionLaunch.isRelaunchableProviderSession('shell', 'exec bash', { provider: 'codex' }) ||
+      sessionLaunch.isRelaunchableProviderSession('shell', 'exec bash', {}) ||
+      sessionLaunch.isRelaunchableProviderSession('codex', 'node script.js', {})) {
+    fail('session launch relaunchable provider detection changed');
+  }
+  const managedSessionName = tmuxModuleForSessionLaunch.tmuxManagedSessionName({ root: '/tmp/hcc root' }, 'Bad Peer!');
+  if (!managedSessionName.startsWith('hcc-') ||
+      !managedSessionName.endsWith('-bad-peer') ||
+      managedSessionName.length > 80) {
+    fail(`session launch tmux session name changed: ${managedSessionName}`);
+  }
+  const tmuxEnvArgs = tmuxModuleForSessionLaunch.tmuxEnvironmentArgs({
+    A: '1',
+    TMUX: 'ignored',
+    'BAD-NAME': 'ignored',
+    B: 2,
+    C: null
+  });
+  if (JSON.stringify(tmuxEnvArgs) !== JSON.stringify(['-e', 'A=1', '-e', 'B=2'])) {
+    fail(`session launch tmux env args changed: ${JSON.stringify(tmuxEnvArgs)}`);
+  }
+  const isolatedEnvArgs = sessionLaunch.isolatedEnvCommandArgs({
+    A: '1',
+    TMUX_PANE: 'ignored',
+    'BAD-NAME': 'ignored',
+    B: 2,
+    C: null
+  });
+  if (!['/usr/bin/env', 'env'].includes(isolatedEnvArgs[0]) ||
+      isolatedEnvArgs[1] !== '-i' ||
+      !isolatedEnvArgs.includes('A=1') ||
+      !isolatedEnvArgs.includes('B=2') ||
+      isolatedEnvArgs.some((arg) => arg.includes('TMUX_PANE') || arg.includes('BAD-NAME'))) {
+    fail(`session launch isolated env args changed: ${JSON.stringify(isolatedEnvArgs)}`);
+  }
+  for (const helper of [
+    'function runTmux',
+    'function tmuxInstallHint',
+    'function commandExists',
+    'function runInstallCommand',
+    'function tryInstallTmux',
+    'function ensureTmuxAvailable',
+    'function tmuxHasSession',
+    'function tmuxSessionHasClients',
+    'function tmuxKillSession',
+    'function tmuxSessionEnvironmentValue',
+    'function tmuxPaneInfo',
+    'function tmuxCapturePane',
+    'function tmuxCursorInfo',
+    'function tmuxCursorPayload',
+    'function tmuxSendKeys',
+    'function tmuxSendRawLiteral',
+    'function tmuxInCopyMode',
+    'function tmuxExitCopyMode',
+    'function tmuxPasteBuffer',
+    'function readTmuxEscapeSequence',
+    'function isTmuxRawControlChar',
+    'function tmuxSendLiteral'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds tmux helper: ${helper}`);
+  }
+  const tmuxModule = await import(path.join(repoRoot, 'lib', 'tmux.mjs'));
+  for (const name of [
+    'runTmux',
+    'tryInstallTmux',
+    'ensureTmuxAvailable',
+    'tmuxHasSession',
+    'tmuxSessionHasClients',
+    'tmuxKillSession',
+    'tmuxSessionEnvironmentValue',
+    'tmuxLaunchFingerprint',
+    'tmuxPaneInfo',
+    'tmuxCapturePane',
+    'tmuxCursorInfo',
+    'tmuxCursorPayload',
+    'tmuxSendLiteral'
+  ]) {
+    if (typeof tmuxModule[name] !== 'function') fail(`tmux module missing export: ${name}`);
+  }
+  const cursorPayload = tmuxModule.tmuxCursorPayload('a\nb\nc\nd', {
+    x: 3,
+    y: 1,
+    visible: true,
+    history: 2,
+    height: 4
+  });
+  if (JSON.stringify(cursorPayload) !== JSON.stringify({ row: 3, col: 3, visible: true })) {
+    fail(`tmux cursor payload mapping changed: ${JSON.stringify(cursorPayload)}`);
+  }
+  const clampedCursorPayload = tmuxModule.tmuxCursorPayload('a\nb\nc\nd\ne', {
+    x: 4,
+    y: 1,
+    visible: false,
+    history: 5,
+    height: 3
+  });
+  if (JSON.stringify(clampedCursorPayload) !== JSON.stringify({ row: 2, col: 4, visible: false }) ||
+      tmuxModule.tmuxCursorPayload('', null) !== null) {
+    fail(`tmux cursor payload clamp/null behavior changed: ${JSON.stringify(clampedCursorPayload)}`);
+  }
+  for (const helper of [
+    'function providerSessionPeerId',
+    'function providerSessionParts',
+    'function inferPeerKind',
+    'function hasResumeOpts',
+    'function defaultSessionCommand',
+    'function buildPeerCommand',
+    'function buildCodexCommand',
+    'function buildClaudeCommand',
+    'function bindingFromRun',
+    'function parseClaudeCommandArgs',
+    'function parseCodexCommandArgs'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds provider command helper: ${helper}`);
+  }
+  const providerCommandsSource = fs.readFileSync(path.join(repoRoot, 'lib', 'integrations', 'providers.mjs'), 'utf8');
+  const compatProviderCommandsSource = fs.readFileSync(path.join(repoRoot, 'lib', 'provider-commands.mjs'), 'utf8');
+  if (!providerCommandsSource.includes("from '../core/peers/session.mjs'") ||
+      providerCommandsSource.includes('function providerSessionPeerId') ||
+      providerCommandsSource.includes('function providerSessionParts')) {
+    fail('integrations provider module no longer delegates peer session helpers to core/peers/session.mjs');
+  }
+  if (!compatProviderCommandsSource.includes("from './integrations/providers.mjs'")) {
+    fail('provider command compat module no longer re-exports integrations/providers.mjs');
+  }
+  const providerCommands = await import(path.join(repoRoot, 'lib', 'integrations', 'providers.mjs'));
+  const compatProviderCommands = await import(path.join(repoRoot, 'lib', 'provider-commands.mjs'));
+  const peerSession = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'session.mjs'));
+  for (const name of [
+    'providerSessionPeerId',
+    'providerSessionParts',
+    'inferPeerKind',
+    'hasResumeOpts',
+    'defaultSessionCommand',
+    'buildPeerCommand',
+    'buildCodexCommand',
+    'buildClaudeCommand',
+    'bindingFromRun',
+    'parseClaudeCommandArgs',
+    'parseCodexCommandArgs'
+  ]) {
+    if (typeof providerCommands[name] !== 'function') fail(`provider command module missing export: ${name}`);
+    if (typeof compatProviderCommands[name] !== 'function') fail(`provider command compat module missing export: ${name}`);
+  }
+  for (const name of ['providerSessionPeerId', 'providerSessionParts']) {
+    if (typeof peerSession[name] !== 'function') fail(`peer session module missing export: ${name}`);
+    if (providerCommands[name] !== peerSession[name]) fail(`provider command module no longer re-exports peer session helper: ${name}`);
+    if (compatProviderCommands[name] !== providerCommands[name]) fail(`provider command compat module no longer re-exports helper: ${name}`);
+  }
+  const providerNameSession = peerSession.providerSessionParts('named-session');
+  if (providerNameSession.provider_session_name !== 'named-session' || providerNameSession.provider_session_id !== null) {
+    fail(`provider command module misclassified named session: ${JSON.stringify(providerNameSession)}`);
+  }
+  const providerUuidSession = peerSession.providerSessionParts('00000000-0000-0000-0000-000000000000');
+  if (providerUuidSession.provider_session_id !== '00000000-0000-0000-0000-000000000000' || providerUuidSession.provider_session_name !== null) {
+    fail(`provider command module misclassified UUID session: ${JSON.stringify(providerUuidSession)}`);
+  }
+  const builtClaude = providerCommands.buildPeerCommand('claude-peer', 'claude', { resume: 'named-session' }, []);
+  if (builtClaude.command !== 'claude --resume named-session' ||
+      builtClaude.binding.resume_mode !== 'resume' ||
+      builtClaude.binding.provider_session_name !== 'named-session') {
+    fail(`provider command module built wrong Claude resume command: ${JSON.stringify(builtClaude)}`);
+  }
+  const builtCodex = providerCommands.buildPeerCommand('codex-peer', 'codex', { resume: 'codex-session' }, []);
+  if (builtCodex.command !== 'codex resume codex-session' ||
+      builtCodex.binding.resume_mode !== 'resume' ||
+      builtCodex.binding.provider_session_name !== 'codex-session') {
+    fail(`provider command module built wrong Codex resume command: ${JSON.stringify(builtCodex)}`);
+  }
+  const parsedCodex = providerCommands.parseCodexCommandArgs(['codex', 'resume', '--model', 'gpt-test', 'codex-session']);
+  if (parsedCodex.resume_mode !== 'resume' ||
+      parsedCodex.resume_arg !== 'codex-session' ||
+      parsedCodex.session.provider_session_name !== 'codex-session') {
+    fail(`provider command module parsed Codex resume args wrong: ${JSON.stringify(parsedCodex)}`);
+  }
+  const parsedClaude = providerCommands.parseClaudeCommandArgs(['claude', '--resume', 'claude-session', '--fork-session']);
+  if (parsedClaude.resume_mode !== 'fork-resume' ||
+      parsedClaude.resume_arg !== 'claude-session' ||
+      parsedClaude.session.provider_session_name !== null) {
+    fail(`provider command module parsed Claude fork resume args wrong: ${JSON.stringify(parsedClaude)}`);
+  }
+  for (const helper of [
+    'function bindingFromDetected(',
+    'function peerBindingRuntimeRank(',
+    'function comparePeerBindings(',
+    'function dedupePeerBindingRows(',
+    'function dedupeProviderSessionColumn(',
+    'function dedupeRuntimeTargets(',
+    'function dedupePeerBindings(',
+    'function bindingHasProviderSession(',
+    'function bindingProviderSessionValue(',
+    'function bindingHasRuntime(',
+    'function mergePeerBinding(',
+    'function mergeRuntimeBinding(',
+    'function findProviderSessionBinding(',
+    'function canonicalizePeerBinding(',
+    'function upsertPeerBinding(',
+    'function upsertCanonicalPeerBinding('
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds peer binding helper: ${helper}`);
+  }
+  const peerBindings = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'bindings.mjs'));
+  const peerReconcile = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'reconcile.mjs'));
+  const peerBindingStoreModule = await import(path.join(repoRoot, 'lib', 'db', 'stores', 'peers.mjs'));
+  const compatPeerBindings = await import(path.join(repoRoot, 'lib', 'peer-bindings.mjs'));
+  for (const name of [
+    'bindingFromDetected',
+    'peerBindingRuntimeRank',
+    'comparePeerBindings',
+    'bindingHasProviderSession',
+    'bindingProviderSessionValue',
+    'bindingHasRuntime',
+    'mergePeerBinding',
+    'mergeRuntimeBinding'
+  ]) {
+    if (typeof peerBindings[name] !== 'function') fail(`peer binding module missing export: ${name}`);
+    if (typeof compatPeerBindings[name] !== 'function') fail(`peer binding compat module missing export: ${name}`);
+  }
+  if (typeof peerBindingStoreModule.createPeerBindingStore !== 'function') {
+    fail('peer binding store module missing createPeerBindingStore');
+  }
+  if (typeof peerReconcile.reconcileRunningPeerBindings !== 'function') {
+    fail('peer reconcile module missing reconcileRunningPeerBindings');
+  }
+  if (typeof compatPeerBindings.createPeerBindingStore !== 'function') {
+    fail('peer binding compat module missing createPeerBindingStore');
+  }
+  const detectedBinding = peerBindings.bindingFromDetected({
+    id: 'detected-peer',
+    kind: 'claude',
+    sessionId: 'detected-session',
+    command: 'claude'
+  });
+  if (detectedBinding.peer !== 'detected-peer' ||
+      detectedBinding.provider !== 'claude' ||
+      detectedBinding.provider_session_name !== 'detected-session' ||
+      detectedBinding.resume_mode !== 'detected' ||
+      detectedBinding.runtime_session_id !== 'detected-peer') {
+    fail(`peer binding module built wrong detected binding: ${JSON.stringify(detectedBinding)}`);
+  }
+  if (peerBindings.peerBindingRuntimeRank({ transport: 'tmux', runtime_target: '%1' }) <= peerBindings.peerBindingRuntimeRank({ transport: 'detected' })) {
+    fail('peer binding runtime rank no longer prefers tmux runtime bindings over detected bindings');
+  }
+  const mergedRuntime = peerBindings.mergeRuntimeBinding(
+    { peer: 'runtime-peer', command: 'codex resume old', transport: 'tmux', runtime_session_id: 'runtime-peer', runtime_target: '%9' },
+    { peer: 'runtime-peer', provider: 'codex', provider_session_name: 'session-a', transport: 'hook', runtime_session_id: 'runtime-peer' }
+  );
+  if (mergedRuntime.transport !== 'tmux' || mergedRuntime.runtime_target !== '%9' || mergedRuntime.command !== 'codex resume old') {
+    fail(`peer binding module did not preserve existing runtime binding: ${JSON.stringify(mergedRuntime)}`);
+  }
+  const mergedProviderSession = peerBindings.mergePeerBinding(
+    { peer: 'session-peer', provider: 'claude', provider_session_id: '00000000-0000-0000-0000-000000000000', provider_session_name: null, resume_mode: 'detected', resume_arg: null, transport: 'hook', runtime_session_id: 'session-peer' },
+    { peer: 'session-peer', provider: 'claude', provider_session_id: null, provider_session_name: null, resume_mode: 'attached', resume_arg: '%pane', command: 'tmux %pane (claude)', transport: 'tmux', runtime_session_id: 'session-peer', runtime_target: '%pane' }
+  );
+  if (mergedProviderSession.provider_session_id !== '00000000-0000-0000-0000-000000000000' ||
+      mergedProviderSession.transport !== 'tmux' ||
+      mergedProviderSession.runtime_target !== '%pane' ||
+      mergedProviderSession.resume_mode !== 'detected') {
+    fail(`peer binding module did not preserve known provider session during runtime attach: ${JSON.stringify(mergedProviderSession)}`);
+  }
+  const peerBindingEvents = [];
+  const peerBindingStore = peerBindingStoreModule.createPeerBindingStore({
+    now: () => 2000,
+    addEvent: (_db, type, actor, taskId, payload) => peerBindingEvents.push({ type, actor, taskId, payload })
+  });
+  for (const name of [
+    'canonicalizePeerBinding',
+    'dedupePeerBindings',
+    'dedupePeerBindingRows',
+    'dedupeProviderSessionColumn',
+    'dedupeRuntimeTargets',
+    'findProviderSessionBinding',
+    'upsertCanonicalPeerBinding',
+    'upsertPeerBinding'
+  ]) {
+    if (typeof peerBindingStore[name] !== 'function') fail(`peer binding store missing function: ${name}`);
+  }
+  const peerBindingDb = new DatabaseSync(':memory:');
+  try {
+    peerBindingDb.exec(`
+      CREATE TABLE peer_bindings (
+        peer TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        provider_session_id TEXT,
+        provider_session_name TEXT,
+        resume_mode TEXT NOT NULL DEFAULT 'new',
+        resume_arg TEXT,
+        command TEXT,
+        transport TEXT NOT NULL,
+        runtime_session_id TEXT,
+        runtime_target TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+    const insertBinding = peerBindingDb.prepare(`
+      INSERT INTO peer_bindings(
+        peer, provider, provider_session_id, provider_session_name, resume_mode,
+        resume_arg, command, transport, runtime_session_id, runtime_target, created_at, updated_at
+      ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    insertBinding.run('detected-old', 'codex', 'same-session', 'detected', null, null, 'detected', 'detected-old', null, 1000, 1000);
+    insertBinding.run('runtime-new', 'codex', 'same-session', 'resume', 'same-session', 'codex resume same-session', 'tmux', 'runtime-new', '%pane', 1000, 1100);
+    const deleted = peerBindingStore.dedupePeerBindings(peerBindingDb);
+    const dedupedRows = peerBindingDb.prepare('SELECT peer FROM peer_bindings ORDER BY peer').all();
+    if (deleted !== undefined || dedupedRows.length !== 1 || dedupedRows[0].peer !== 'runtime-new') {
+      fail(`peer binding dedupe did not keep runtime binding: ${JSON.stringify(dedupedRows)}`);
+    }
+    const canonical = peerBindingStore.upsertCanonicalPeerBinding(peerBindingDb, {
+      peer: 'hook-peer',
+      provider: 'codex',
+      provider_session_id: null,
+      provider_session_name: 'same-session',
+      resume_mode: 'detected',
+      resume_arg: null,
+      command: null,
+      transport: 'hook',
+      runtime_session_id: 'hook-peer'
+    }, true);
+    if (canonical.peer !== 'runtime-new' || canonical.merged_from !== 'hook-peer') {
+      fail(`peer binding canonicalization did not merge hook peer into runtime peer: ${JSON.stringify(canonical)}`);
+    }
+    const canonicalRow = peerBindingDb.prepare('SELECT peer, transport, runtime_target, provider_session_name FROM peer_bindings WHERE peer = ?').get('runtime-new');
+    if (canonicalRow.transport !== 'tmux' || canonicalRow.runtime_target !== '%pane' || canonicalRow.provider_session_name !== 'same-session') {
+      fail(`peer binding canonical upsert lost runtime fields: ${JSON.stringify(canonicalRow)}`);
+    }
+    if (!peerBindingEvents.some((event) => event.type === 'provider.session.deduped')) {
+      fail(`peer binding dedupe did not emit provider.session.deduped: ${JSON.stringify(peerBindingEvents)}`);
+    }
+  } finally {
+    peerBindingDb.close();
+  }
+  const reconcileDb = new DatabaseSync(':memory:');
+  try {
+    reconcileDb.exec(`
+      CREATE TABLE peers (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        role TEXT,
+        worktree TEXT,
+        branch TEXT,
+        pid INTEGER,
+        status TEXT NOT NULL DEFAULT 'idle',
+        capabilities TEXT,
+        created_at INTEGER NOT NULL,
+        last_seen_at INTEGER NOT NULL
+      );
+      CREATE TABLE peer_bindings (
+        peer TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        provider_session_id TEXT,
+        provider_session_name TEXT,
+        resume_mode TEXT NOT NULL DEFAULT 'new',
+        resume_arg TEXT,
+        command TEXT,
+        transport TEXT NOT NULL,
+        runtime_session_id TEXT,
+        runtime_target TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        actor TEXT,
+        task_id INTEGER,
+        payload TEXT,
+        created_at INTEGER NOT NULL
+      );
+      CREATE UNIQUE INDEX idx_reconcile_provider_session_id
+        ON peer_bindings(provider, provider_session_id)
+        WHERE provider_session_id IS NOT NULL;
+      CREATE UNIQUE INDEX idx_reconcile_provider_session_name
+        ON peer_bindings(provider, provider_session_name)
+        WHERE provider_session_name IS NOT NULL;
+    `);
+    const t = 3000;
+    const insertPeer = reconcileDb.prepare(`
+      INSERT INTO peers(id, kind, role, worktree, branch, pid, status, capabilities, created_at, last_seen_at)
+      VALUES (?, ?, 'peer', ?, 'master', ?, ?, '', ?, ?)
+    `);
+    const insertBinding = reconcileDb.prepare(`
+      INSERT INTO peer_bindings(
+        peer, provider, provider_session_id, provider_session_name, resume_mode,
+        resume_arg, command, transport, runtime_session_id, runtime_target, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tmux', ?, ?, ?, ?)
+    `);
+    insertPeer.run('hook-known-peer', 'claude', root, 111, 'running', t, t);
+    insertBinding.run('hook-known-peer', 'claude', null, null, 'attached', '%1', 'tmux %1 (claude)', 'hook-known-peer', '%1', t, t);
+    insertPeer.run('argv-peer', 'codex', root, 222, 'running', t, t);
+    insertBinding.run('argv-peer', 'codex', null, null, 'unknown', '%2', 'codex resume', 'argv-peer', '%2', t, t);
+    insertPeer.run('weak-peer', 'codex', root, 333, 'running', t, t);
+    insertBinding.run('weak-peer', 'codex', null, null, 'unknown', '%3', 'codex resume', 'weak-peer', '%3', t, t);
+    insertPeer.run('known-peer', 'claude', root, 444, 'running', t, t);
+    insertBinding.run('known-peer', 'claude', '11111111-1111-1111-1111-111111111111', null, 'detected', null, null, 'known-peer', '%4', t, t);
+    insertPeer.run('conflict-peer', 'claude', root, 555, 'running', t, t);
+    insertBinding.run('conflict-peer', 'claude', '33333333-3333-3333-3333-333333333333', null, 'detected', null, null, 'conflict-peer', '%5', t, t);
+    insertPeer.run('conflict-new-peer', 'claude', root, 556, 'running', t, t);
+    insertBinding.run('conflict-new-peer', 'claude', null, null, 'attached', '%6', 'tmux %6 (claude)', 'conflict-new-peer', '%6', t, t);
+    insertPeer.run('provider-mismatch-conflict', 'codex', root, 666, 'running', t, t);
+    insertBinding.run('provider-mismatch-conflict', 'codex', null, 'mismatch-session', 'detected', null, null, 'provider-mismatch-conflict', '%7', t, t);
+    insertPeer.run('provider-mismatch-new', 'shell', root, 667, 'running', t, t);
+    insertBinding.run('provider-mismatch-new', 'shell', null, null, 'attached', '%8', 'tmux %8 (bash)', 'provider-mismatch-new', '%8', t, t);
+
+    const reconcileEvents = [];
+    const reconciled = peerReconcile.reconcileRunningPeerBindings(reconcileDb, { root }, {
+      now: () => 4000,
+      panes: [
+        { pane: '%1', pid: 111, cwd: root },
+        { pane: '%2', pid: 222, cwd: root },
+        { pane: '%3', pid: 333, cwd: root },
+        { pane: '%4', pid: 444, cwd: root },
+        { pane: '%5', pid: 555, cwd: root },
+        { pane: '%6', pid: 556, cwd: root },
+        { pane: '%7', pid: 666, cwd: root },
+        { pane: '%8', pid: 667, cwd: root }
+      ],
+      latestProviderSessionForPeer: (peer) => {
+        if (peer === 'hook-known-peer') return '22222222-2222-2222-2222-222222222222';
+        if (peer === 'conflict-new-peer') return '33333333-3333-3333-3333-333333333333';
+        return null;
+      },
+      inspectProcess: (pid) => {
+        if (pid === 222) return { kind: 'codex', provider_session: 'argv-session', source: 'process.argv.codex' };
+        if (pid === 667) return { kind: 'codex', provider_session: 'mismatch-session', source: 'process.argv.codex' };
+        return null;
+      },
+      addEvent: (_db, type, actor, taskId, payload) => reconcileEvents.push({ type, actor, taskId, payload })
+    });
+    if (reconciled.backfilled !== 2) {
+      fail(`peer binding reconcile did not backfill exactly two strong-evidence rows: ${JSON.stringify(reconciled, null, 2)}`);
+    }
+    const hookKnown = reconcileDb.prepare('SELECT provider_session_id, provider_session_name, resume_mode, resume_arg FROM peer_bindings WHERE peer = ?').get('hook-known-peer');
+    if (hookKnown.provider_session_id !== '22222222-2222-2222-2222-222222222222' || hookKnown.provider_session_name !== null) {
+      fail(`peer binding reconcile did not backfill hook event session id: ${JSON.stringify(hookKnown)}`);
+    }
+    const argvKnown = reconcileDb.prepare('SELECT provider_session_id, provider_session_name, resume_mode, resume_arg FROM peer_bindings WHERE peer = ?').get('argv-peer');
+    if (argvKnown.provider_session_id !== null || argvKnown.provider_session_name !== 'argv-session') {
+      fail(`peer binding reconcile did not backfill process argv session name: ${JSON.stringify(argvKnown)}`);
+    }
+    const weakKnown = reconcileDb.prepare('SELECT provider_session_id, provider_session_name FROM peer_bindings WHERE peer = ?').get('weak-peer');
+    if (weakKnown.provider_session_id !== null || weakKnown.provider_session_name !== null) {
+      fail(`peer binding reconcile wrote weak-evidence provider session: ${JSON.stringify(weakKnown)}`);
+    }
+    const conflictNew = reconcileDb.prepare('SELECT provider_session_id, provider_session_name FROM peer_bindings WHERE peer = ?').get('conflict-new-peer');
+    if (conflictNew.provider_session_id !== null || conflictNew.provider_session_name !== null ||
+        !reconciled.results.some((result) => result.peer === 'conflict-new-peer' && result.reason === 'provider_session_conflict')) {
+      fail(`peer binding reconcile did not skip conflicting provider session safely: ${JSON.stringify({ conflictNew, reconciled }, null, 2)}`);
+    }
+    const mismatchNew = reconcileDb.prepare('SELECT provider, provider_session_id, provider_session_name FROM peer_bindings WHERE peer = ?').get('provider-mismatch-new');
+    if (mismatchNew.provider !== 'shell' || mismatchNew.provider_session_id !== null || mismatchNew.provider_session_name !== null ||
+        !reconciled.results.some((result) => result.peer === 'provider-mismatch-new' && result.provider === 'codex' && result.reason === 'provider_session_conflict')) {
+      fail(`peer binding reconcile did not use candidate provider for conflict detection: ${JSON.stringify({ mismatchNew, reconciled }, null, 2)}`);
+    }
+    if (!reconcileEvents.some((event) => event.type === 'provider.session.backfilled' && event.actor === 'hook-known-peer') ||
+        !reconcileEvents.some((event) => event.type === 'provider.session.backfilled' && event.actor === 'argv-peer')) {
+      fail(`peer binding reconcile did not emit backfill events: ${JSON.stringify(reconcileEvents)}`);
+    }
+  } finally {
+    reconcileDb.close();
+  }
+  for (const helper of [
+    'const WHOLE_LOCK_SCOPE',
+    'function normalizeLockScope',
+    'function scopedLockResource',
+    'function lockBaseResource',
+    'function lockScope',
+    'function lockLabel',
+    'function lockArgv',
+    'function locksConflict'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds lock helper: ${helper}`);
+  }
+  const locksModule = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'locks.mjs'));
+  const compatLocksModule = await import(path.join(repoRoot, 'lib', 'locks.mjs'));
+  for (const name of [
+    'normalizeLockScope',
+    'scopedLockResource',
+    'lockBaseResource',
+    'lockScope',
+    'lockLabel',
+    'lockArgv',
+    'locksConflict'
+  ]) {
+    if (typeof locksModule[name] !== 'function') fail(`locks module missing export: ${name}`);
+    if (typeof compatLocksModule[name] !== 'function') fail(`locks compat module missing export: ${name}`);
+  }
+  const wholeLock = locksModule.scopedLockResource('bin/hcc.mjs', '');
+  const scopedLock = locksModule.scopedLockResource('bin/hcc.mjs', 'provider-commands');
+  if (wholeLock.resource !== 'bin/hcc.mjs' ||
+      wholeLock.base_resource !== 'bin/hcc.mjs' ||
+      wholeLock.scope !== '*') {
+    fail(`locks module built wrong whole-resource lock: ${JSON.stringify(wholeLock)}`);
+  }
+  if (!scopedLock.resource.startsWith('scoped:') ||
+      scopedLock.base_resource !== 'bin/hcc.mjs' ||
+      scopedLock.scope !== 'provider-commands' ||
+      locksModule.lockLabel(scopedLock) !== 'bin/hcc.mjs [provider-commands]') {
+    fail(`locks module built wrong scoped lock: ${JSON.stringify(scopedLock)}`);
+  }
+  if (!locksModule.locksConflict(wholeLock, scopedLock) ||
+      locksModule.locksConflict(scopedLock, locksModule.scopedLockResource('bin/hcc.mjs', 'tmux-helpers')) ||
+      locksModule.locksConflict(scopedLock, locksModule.scopedLockResource('scripts/regression.mjs', 'provider-commands'))) {
+    fail('locks module conflict behavior changed');
+  }
+  for (const helper of [
+    'function splitCsvList',
+    'function parseTeamItems',
+    'function inferTeamItems',
+    'function expandTeamWorkers',
+    'function assignTeamWorkers'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds team planning helper: ${helper}`);
+  }
+  const teamPlanning = await import(path.join(repoRoot, 'lib', 'core', 'coordination', 'teams.mjs'));
+  const compatTeamPlanning = await import(path.join(repoRoot, 'lib', 'team-planning.mjs'));
+  for (const name of [
+    'splitCsvList',
+    'parseTeamItems',
+    'inferTeamItems',
+    'expandTeamWorkers',
+    'assignTeamWorkers'
+  ]) {
+    if (typeof teamPlanning[name] !== 'function') fail(`team planning module missing export: ${name}`);
+    if (typeof compatTeamPlanning[name] !== 'function') fail(`team planning compat module missing export: ${name}`);
+  }
+  const splitTeam = teamPlanning.splitCsvList(['codex:2, claude-a', ' docs-a ']);
+  if (JSON.stringify(splitTeam) !== JSON.stringify(['codex:2', 'claude-a', 'docs-a'])) {
+    fail(`team planning splitCsvList changed: ${JSON.stringify(splitTeam)}`);
+  }
+  const parsedTeam = teamPlanning.parseTeamItems({
+    item: ['docs:Update docs', 'codex-a:tests:Add: regression']
+  });
+  if (parsedTeam.length !== 2 ||
+      parsedTeam[0].role !== 'docs' ||
+      parsedTeam[0].title !== 'Update docs' ||
+      parsedTeam[1].assignee !== 'codex-a' ||
+      parsedTeam[1].role !== 'tests' ||
+      parsedTeam[1].title !== 'Add:regression') {
+    fail(`team planning parseTeamItems changed: ${JSON.stringify(parsedTeam)}`);
+  }
+  const inferredTeam = teamPlanning.inferTeamItems({ title: 'Parent task' }, { count: '0' });
+  if (inferredTeam.length !== 1 || inferredTeam[0].title !== 'Parent task / subtask 1') {
+    fail(`team planning count normalization changed: ${JSON.stringify(inferredTeam)}`);
+  }
+  try {
+    teamPlanning.inferTeamItems({ title: 'Parent task' }, { count: 'not-a-number' });
+    fail('team planning accepted non-integer count');
+  } catch (err) {
+    if (err?.code !== 'BAD_ARGS') throw err;
+  }
+  const expandedWorkers = teamPlanning.expandTeamWorkers(['Codex:2', 'claude-a'], 42);
+  if (JSON.stringify(expandedWorkers) !== JSON.stringify(['codex-team-42-1', 'codex-team-42-2', 'claude-a'])) {
+    fail(`team planning worker expansion changed: ${JSON.stringify(expandedWorkers)}`);
+  }
+  const assignedTeam = teamPlanning.assignTeamWorkers(parsedTeam, ['codex:2'], 42);
+  if (assignedTeam[0].assignee !== 'codex-team-42-1' || assignedTeam[1].assignee !== 'codex-a') {
+    fail(`team planning worker assignment changed: ${JSON.stringify(assignedTeam)}`);
+  }
+  const peerFormat = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'format.mjs'));
+  const compatPeerFormat = await import(path.join(repoRoot, 'lib', 'peer-format.mjs'));
+  if (typeof peerFormat.sanitizePeerPart !== 'function' ||
+      typeof peerFormat.shortHash !== 'function' ||
+      typeof compatPeerFormat.sanitizePeerPart !== 'function' ||
+      typeof compatPeerFormat.shortHash !== 'function' ||
+      peerFormat.sanitizePeerPart('Bad Peer!', 'fallback') !== 'bad-peer' ||
+      peerFormat.sanitizePeerPart('!!!', 'fallback') !== 'fallback' ||
+      peerFormat.shortHash('hello') !== 'aaf4c61d') {
+    fail('peer format module behavior changed');
+  }
+  for (const [label, source, expectedImport] of [
+    ['peer session', fs.readFileSync(path.join(repoRoot, 'lib', 'core', 'peers', 'session.mjs'), 'utf8'), "from './format.mjs'"],
+    ['team planning', fs.readFileSync(path.join(repoRoot, 'lib', 'core', 'coordination', 'teams.mjs'), 'utf8'), "from '../peers/format.mjs'"],
+    ['peer identity', fs.readFileSync(path.join(repoRoot, 'lib', 'core', 'peers', 'identity.mjs'), 'utf8'), "from './format.mjs'"]
+  ]) {
+    if (!source.includes(expectedImport)) fail(`${label} module does not import peer format helpers`);
+    if (source.includes('function sanitizePeerPart') || source.includes('function shortHash')) {
+      fail(`${label} module still embeds peer format helpers`);
+    }
+  }
+  const corePeerIdentitySource = fs.readFileSync(path.join(repoRoot, 'lib', 'core', 'peers', 'identity.mjs'), 'utf8');
+  if (corePeerIdentitySource.includes('process.env') ||
+      corePeerIdentitySource.includes('spawnSync(') ||
+      corePeerIdentitySource.includes('/proc/')) {
+    fail('core peer identity still contains process or procfs observation logic');
+  }
+  for (const helper of [
+    'function sanitizePeerPart',
+    'function shortHash',
+    'function currentTtyName',
+    'function readProcCmdline',
+    'function readProcEnv',
+    'function readProcParentPid',
+    'function argsLookLikeCli',
+    'function detectCliKindFromProcess',
+    'function readAncestorCliInfo',
+    'function resumeIdFromArgs',
+    'function autoPeerProviderSession',
+    'function autoPeerSessionId',
+    'function autoPeerResumeId',
+    'function autoPeerKind',
+    'function autoPeerBasis',
+    'function autoPeerId',
+    'function resolveCurrentPeer',
+    'function currentPeer'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds peer identity helper: ${helper}`);
+  }
+  const peerIdentity = await import(path.join(repoRoot, 'lib', 'core', 'peers', 'identity.mjs'));
+  const integrationPeerIdentity = await import(path.join(repoRoot, 'lib', 'integrations', 'peers', 'identity.mjs'));
+  const compatPeerIdentity = await import(path.join(repoRoot, 'lib', 'peer-identity.mjs'));
+  for (const name of [
+    'sanitizePeerPart',
+    'shortHash',
+    'autoPeerProviderSession',
+    'autoPeerSessionId',
+    'autoPeerResumeId',
+    'autoPeerKind',
+    'autoPeerBasis',
+    'autoPeerId',
+    'resolveCurrentPeer',
+    'currentPeer'
+  ]) {
+    if (typeof peerIdentity[name] !== 'function') fail(`peer identity core module missing export: ${name}`);
+  }
+  for (const name of [
+    'sanitizePeerPart',
+    'shortHash',
+    'currentTtyName',
+    'readAncestorCliInfo',
+    'resumeIdFromArgs',
+    'autoPeerProviderSession',
+    'autoPeerSessionId',
+    'autoPeerResumeId',
+    'autoPeerKind',
+    'autoPeerBasis',
+    'autoPeerId',
+    'resolveCurrentPeer',
+    'currentPeer'
+  ]) {
+    if (typeof integrationPeerIdentity[name] !== 'function') fail(`peer identity integration module missing export: ${name}`);
+    if (typeof compatPeerIdentity[name] !== 'function') fail(`peer identity compat module missing export: ${name}`);
+  }
+  if (peerIdentity.sanitizePeerPart('Bad Peer!', 'fallback') !== 'bad-peer' ||
+      peerIdentity.sanitizePeerPart('!!!', 'fallback') !== 'fallback' ||
+      peerIdentity.shortHash('hello') !== 'aaf4c61d') {
+    fail('peer identity sanitize/hash behavior changed');
+  }
+  if (integrationPeerIdentity.resumeIdFromArgs('claude', ['claude', '--resume', 'named-session']) !== 'named-session' ||
+      integrationPeerIdentity.resumeIdFromArgs('claude', ['claude', '--resume=inline-session']) !== 'inline-session' ||
+      integrationPeerIdentity.resumeIdFromArgs('claude', ['claude', '--resume', 'named-session', '--fork-session']) !== null ||
+      integrationPeerIdentity.resumeIdFromArgs('codex', ['codex', 'resume', 'codex-session']) !== 'codex-session' ||
+      integrationPeerIdentity.resumeIdFromArgs('codex', ['codex', 'resume', '--last']) !== null) {
+    fail('peer identity resume id parsing changed');
+  }
+  const savedPeerEnv = {
+    HCC_PEER: process.env.HCC_PEER,
+    CLAUDE_CODE_SESSION_ID: process.env.CLAUDE_CODE_SESSION_ID,
+    CLAUDECODE: process.env.CLAUDECODE,
+    CODEX_SESSION_ID: process.env.CODEX_SESSION_ID,
+    CODEX_THREAD_ID: process.env.CODEX_THREAD_ID,
+    CODEX_MANAGED_BY_NPM: process.env.CODEX_MANAGED_BY_NPM,
+    CODEX_MANAGED_BY_BUN: process.env.CODEX_MANAGED_BY_BUN
+  };
+  try {
+    process.env.HCC_PEER = 'env-peer';
+    if (integrationPeerIdentity.resolveCurrentPeer({ root: repoRoot }, {}, 'peer', 'shell').id !== 'env-peer') {
+      fail('peer identity resolveCurrentPeer ignored HCC_PEER');
+    }
+    delete process.env.HCC_PEER;
+    delete process.env.CLAUDE_CODE_SESSION_ID;
+    delete process.env.CLAUDECODE;
+    process.env.CODEX_SESSION_ID = '0123456789abcdef';
+    delete process.env.CODEX_THREAD_ID;
+    delete process.env.CODEX_MANAGED_BY_NPM;
+    delete process.env.CODEX_MANAGED_BY_BUN;
+    const autoPeer = integrationPeerIdentity.resolveCurrentPeer({ root: repoRoot }, {}, 'peer', 'shell');
+    if (!autoPeer.auto || autoPeer.id !== 'codex-01234567') {
+      fail(`peer identity auto peer id changed: ${JSON.stringify(autoPeer)}`);
+    }
+    const explicitPeer = integrationPeerIdentity.resolveCurrentPeer({ root: repoRoot }, { peer: 'manual-peer' }, 'peer', 'shell');
+    if (explicitPeer.auto || explicitPeer.id !== 'manual-peer') {
+      fail(`peer identity explicit peer resolution changed: ${JSON.stringify(explicitPeer)}`);
+    }
+  } finally {
+    for (const [key, value] of Object.entries(savedPeerEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+  for (const helper of [
+    'function projectRecord',
+    'function readProjectRegistry',
+    'function writeProjectRegistry',
+    'function registerProject',
+    'function registerProjectActivity'
+  ]) {
+    if (hccSource.includes(helper)) fail(`CLI still embeds project registry helper: ${helper}`);
+  }
+  const projectRegistry = await import(path.join(repoRoot, 'lib', 'runtime', 'projects.mjs'));
+  const compatProjectRegistry = await import(path.join(repoRoot, 'lib', 'project-registry.mjs'));
+  for (const name of [
+    'projectRecord',
+    'readProjectRegistry',
+    'writeProjectRegistry',
+    'registerProject',
+    'registerProjectActivity'
+  ]) {
+    if (typeof projectRegistry[name] !== 'function') fail(`project registry module missing export: ${name}`);
+    if (typeof compatProjectRegistry[name] !== 'function') fail(`project registry compat module missing export: ${name}`);
+  }
+  const savedHome = process.env.HOME;
+  process.env.HOME = home;
+  try {
+    const registryRootA = path.join(root, 'registry-a');
+    const registryRootB = path.join(root, 'registry-b');
+    const missingRegistryRoot = path.join(root, 'registry-missing');
+    fs.mkdirSync(registryRootA, { recursive: true });
+    fs.mkdirSync(registryRootB, { recursive: true });
+    const written = projectRegistry.writeProjectRegistry([
+      { root: registryRootA, db: '', name: '', last_seen_at: '5' },
+      { root: missingRegistryRoot, db: path.join(missingRegistryRoot, 'stale.db'), name: 'Gone', last_seen_at: '20' },
+      { root: registryRootB, db: path.join(registryRootB, 'custom.db'), name: 'Bee', last_seen_at: '10' },
+      { root: registryRootA, db: path.join(registryRootA, 'new.db'), name: 'Aye', last_seen_at: '15' }
+    ]);
+    if (written.length !== 3 ||
+        written[0].root !== path.resolve(missingRegistryRoot) ||
+        written[1].root !== path.resolve(registryRootA) ||
+        written[1].db !== path.resolve(path.join(registryRootA, 'new.db')) ||
+        written[1].name !== 'Aye' ||
+        written[1].last_seen_at !== 15 ||
+        written[2].root !== path.resolve(registryRootB)) {
+      fail(`project registry write/dedupe/sort changed: ${JSON.stringify(written)}`);
+    }
+    const readBack = projectRegistry.readProjectRegistry();
+    if (readBack.length !== 2 ||
+        readBack[0].root !== path.resolve(registryRootA) ||
+        readBack[1].root !== path.resolve(registryRootB) ||
+        readBack.some((p) => p.root === path.resolve(missingRegistryRoot))) {
+      fail(`project registry kept missing root: ${JSON.stringify(readBack)}`);
+    }
+    const recorded = projectRegistry.projectRecord({
+      root: path.resolve(registryRootB),
+      dbPath: path.join(registryRootB, 'mesh.db')
+    }, () => 123);
+    if (recorded.root !== path.resolve(registryRootB) ||
+        recorded.db !== path.join(registryRootB, 'mesh.db') ||
+        recorded.name !== 'registry-b' ||
+        recorded.last_seen_at !== 123) {
+      fail(`project registry record changed: ${JSON.stringify(recorded)}`);
+    }
+    const registered = projectRegistry.registerProject({
+      root: path.resolve(registryRootB),
+      dbPath: path.join(registryRootB, 'mesh.db')
+    });
+    if (registered[0].root !== path.resolve(registryRootB) ||
+        registered.filter((p) => p.root === path.resolve(registryRootB)).length !== 1) {
+      fail(`project registry register changed: ${JSON.stringify(registered)}`);
+    }
+  } finally {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+  }
   for (const helper of [
     'function runtimeBaseUrl',
     'function runtimeApiUrl',
     'function requestUrl',
+    'function isLoopbackHost',
+    'function nextSessionId',
+    'function listenServer',
     'function runtimeUrlQuery',
     'function makeWebToken',
     'function validateWebTokenOpts',
@@ -2271,9 +4668,26 @@ async function syntaxAndHelp() {
   }
   if (hccSource.includes('new URL(req.url')) fail('CLI still embeds raw server request URL parsing');
   if (hccSource.includes('function webIndexHtml()')) fail('CLI still embeds the web UI template');
-  const webRuntime = await import(path.join(repoRoot, 'lib', 'web-runtime.mjs'));
-  const webHttp = await import(path.join(repoRoot, 'lib', 'web-http.mjs'));
-  const webUiTemplate = await import(path.join(repoRoot, 'lib', 'web-ui-template.mjs'));
+  const webRuntime = await import(path.join(repoRoot, 'lib', 'web', 'runtime.mjs'));
+  const webHttp = await import(path.join(repoRoot, 'lib', 'web', 'http.mjs'));
+  const webUiTemplate = await import(path.join(repoRoot, 'lib', 'web', 'ui-template.mjs'));
+  const compatWebRuntime = await import(path.join(repoRoot, 'lib', 'web-runtime.mjs'));
+  const compatWebHttp = await import(path.join(repoRoot, 'lib', 'web-http.mjs'));
+  const compatWebPeerActions = await import(path.join(repoRoot, 'lib', 'web-peer-actions.mjs'));
+  const compatWebUiTemplate = await import(path.join(repoRoot, 'lib', 'web-ui-template.mjs'));
+  for (const [moduleName, mod, names] of [
+    ['web/runtime', webRuntime, ['runtimeConnectHost', 'runtimeBaseUrl', 'runtimeApiUrl', 'requestUrl', 'isLoopbackHost', 'nextSessionId', 'listenServer', 'publicRuntimeUrl', 'localRuntimeUrl', 'makeWebToken', 'expectedWebHost', 'webRuntimeMatchesRequest', 'rememberRuntimeToken']],
+    ['web-runtime compat', compatWebRuntime, ['runtimeConnectHost', 'runtimeBaseUrl', 'runtimeApiUrl', 'requestUrl', 'isLoopbackHost', 'nextSessionId', 'listenServer', 'publicRuntimeUrl', 'localRuntimeUrl', 'makeWebToken', 'expectedWebHost', 'webRuntimeMatchesRequest', 'rememberRuntimeToken']],
+    ['web/http', webHttp, ['readJsonRequest', 'sendHttp', 'sendJson', 'sendFile', 'authOk']],
+    ['web-http compat', compatWebHttp, ['readJsonRequest', 'sendHttp', 'sendJson', 'sendFile', 'authOk']],
+    ['web-peer-actions compat', compatWebPeerActions, ['createWebPeerActions']],
+    ['web/ui-template', webUiTemplate, ['webIndexHtml']],
+    ['web-ui-template compat', compatWebUiTemplate, ['webIndexHtml']]
+  ]) {
+    for (const name of names) {
+      if (typeof mod[name] !== 'function') fail(`${moduleName} missing export: ${name}`);
+    }
+  }
   const expectEqual = (actual, expected, label) => {
     if (actual !== expected) fail(`${label}: expected ${expected}, got ${actual}`);
   };
@@ -2318,6 +4732,26 @@ async function syntaxAndHelp() {
   expectEqual(String(webRuntime.runtimeApiUrl({ base_url: 'http://127.0.0.1:8787/base' }, '/api/state?peer=a b')), 'http://127.0.0.1:8787/api/state?peer=a%20b', 'runtimeApiUrl route');
   expectEqual(String(webRuntime.requestUrl({ url: '/api/state?peer=a b', headers: { host: 'example.test:8787' } })), 'http://example.test:8787/api/state?peer=a%20b', 'requestUrl host and query');
   expectEqual(String(webRuntime.requestUrl({ url: '', headers: {} })), 'http://localhost/', 'requestUrl fallback');
+  if (!webRuntime.isLoopbackHost('127.0.0.1') ||
+      !webRuntime.isLoopbackHost('localhost') ||
+      !webRuntime.isLoopbackHost('::1') ||
+      webRuntime.isLoopbackHost('0.0.0.0')) {
+    fail('web runtime isLoopbackHost checks failed');
+  }
+  expectEqual(webRuntime.nextSessionId(['shell-1', 'shell-2'], 'shell'), 'shell-3', 'nextSessionId array');
+  expectEqual(webRuntime.nextSessionId(new Map([
+    ['a', { id: 'codex-1' }],
+    ['b', 'codex-2']
+  ]), 'codex'), 'codex-3', 'nextSessionId map');
+  const listenProbe = http.createServer((req, res) => res.end('ok'));
+  try {
+    const listenPort = await webRuntime.listenServer(listenProbe, '127.0.0.1', 0, false);
+    if (!Number.isInteger(listenPort) || listenPort <= 0) {
+      fail(`listenServer did not return a usable port: ${listenPort}`);
+    }
+  } finally {
+    await new Promise((resolve) => listenProbe.close(resolve));
+  }
   expectEqual(webRuntime.publicRuntimeUrl(wildcardRuntime, '/tmp/hcc project'), 'http://<machine-ip>:8787/?token=tok&project=%2Ftmp%2Fhcc%20project', 'publicRuntimeUrl wildcard');
   expectEqual(webRuntime.localRuntimeUrl(wildcardRuntime, '/tmp/hcc project'), 'http://127.0.0.1:8787/?token=tok&project=%2Ftmp%2Fhcc%20project', 'localRuntimeUrl wildcard');
   expectEqual(webRuntime.publicRuntimeUrl(ipv6WildcardRuntime, '/tmp/hcc project'), 'http://<machine-ip>:8788/?token=tok&project=%2Ftmp%2Fhcc%20project', 'publicRuntimeUrl ipv6 wildcard');
@@ -2338,6 +4772,9 @@ async function syntaxAndHelp() {
   if (!mainHelp.includes('  uninstall                    Remove hooks, shims, and optional project data')) {
     fail(`main help missing uninstall command:\n${mainHelp}`);
   }
+  if (!mainHelp.includes('  tmux gc [--yes]              Clean stale DB-proven hcc-managed tmux sessions')) {
+    fail(`main help missing tmux gc command:\n${mainHelp}`);
+  }
   const msgHelp = run(process.execPath, [hccBin, 'msg', '--help']);
   if (!msgHelp.includes('msg reply') || !msgHelp.includes('msg thread')) {
     fail(`msg help missing reply/thread commands:\n${msgHelp}`);
@@ -2373,6 +4810,19 @@ async function syntaxAndHelp() {
   if (!updateHelp.includes('hcc update') || !updateHelp.includes('npm install -g @logicseek/hello-cc@TAG')) {
     fail(`update help missing expected content:\n${updateHelp}`);
   }
+  const tmuxHelp = run(process.execPath, [hccBin, 'tmux', '--help']);
+  if (!tmuxHelp.includes('hcc tmux') ||
+      !tmuxHelp.includes('tmux gc [--peer ID] [--older-than DAYS]') ||
+      !tmuxHelp.includes('peer_bindings.transport must be tmux') ||
+      !tmuxHelp.includes('deletion requires --yes')) {
+    fail(`tmux help missing DB-backed gc semantics:\n${tmuxHelp}`);
+  }
+  const gcHelp = run(process.execPath, [hccBin, 'gc', '--help']);
+  if (!gcHelp.includes('hcc gc') ||
+      !gcHelp.includes('gc [--older-than DAYS] [--yes]') ||
+      !gcHelp.includes('deletion requires --yes')) {
+    fail(`gc help missing cleanup semantics:\n${gcHelp}`);
+  }
   const uninstallHelp = run(process.execPath, [hccBin, 'uninstall', '--help']);
   if (!uninstallHelp.includes('hcc uninstall') || !uninstallHelp.includes('hcc uninstall [--purge --yes]')) {
     fail(`uninstall help missing expected content:\n${uninstallHelp}`);
@@ -2395,6 +4845,7 @@ async function syntaxAndHelp() {
     ['task', 'done', 'hcc task done'],
     ['msg', 'reply', 'hcc msg reply'],
     ['peer', 'attach', 'peer attach'],
+    ['tmux', 'gc', 'hcc tmux'],
     ['lock', 'release', 'hcc lock release'],
     ['handoff', 'create', 'hcc handoff create'],
     ['event', 'tail', 'hcc event tail']