@logicseek/hello-cc 0.1.7 → 0.1.9

package/scripts/regression.mjs

@@ -38,7 +38,8 @@ const managedTmuxSessions = new Set();
 const env = {
   ...process.env,
   HOME: home,
-  PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`
+  PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`,
+  SHELL: '/bin/bash'
 };
 for (const key of Object.keys(env)) {
   if (key.startsWith('HCC_')) delete env[key];
@@ -51,6 +52,13 @@ function log(message) {
 }
 
 function fail(message) {
+  if (process.env.GITHUB_ACTIONS === 'true') {
+    const escaped = String(message)
+      .replace(/%/g, '%25')
+      .replace(/\r/g, '%0D')
+      .replace(/\n/g, '%0A');
+    process.stderr.write(`::error::${escaped}\n`);
+  }
   throw new Error(message);
 }
 
@@ -62,6 +70,20 @@ function sh(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
 
+function canonicalPath(value) {
+  try { return fs.realpathSync(value); }
+  catch { return path.resolve(value); }
+}
+
+function samePath(a, b) {
+  return canonicalPath(a) === canonicalPath(b);
+}
+
+function statusValue(output, key) {
+  const match = String(output || '').match(new RegExp(`^${key}:\\s*(.*)$`, 'm'));
+  return match ? match[1].trim() : '';
+}
+
 function shortHash(value) {
   return crypto.createHash('sha1').update(String(value)).digest('hex').slice(0, 8);
 }
@@ -400,7 +422,8 @@ async function assertTmuxGcPolicy() {
     }), 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)}`], {
+  const attachTmux = realTmuxBin ? `${sh(realTmuxBin)} -L ${sh(tmuxSocketName)}` : 'tmux';
+  const client = spawnSync('tmux', ['new-session', '-d', '-s', `${tmuxSession}-gc-client`, '-e', `HCC_ROOT=${root}`, 'sh', '-lc', `unset TMUX; exec ${attachTmux} attach-session -t ${sh(attachedSession)}`], {
     env,
     encoding: 'utf8',
     stdio: ['ignore', 'pipe', 'pipe']
@@ -1023,19 +1046,34 @@ async function waitForFile(file, expected, label = file) {
 }
 
 async function waitForFileContent(file, expected, label = file) {
-  await waitFor(() => {
-    if (!fs.existsSync(file)) return false;
-    return fs.readFileSync(file, 'utf8').trim() === expected;
-  }, label);
+  const deadline = Date.now() + 10000;
+  let actual = '(missing)';
+  while (Date.now() < deadline) {
+    if (fs.existsSync(file)) {
+      actual = fs.readFileSync(file, 'utf8').trim();
+      if (actual === expected) break;
+    }
+    await sleep(100);
+  }
+  if (actual !== expected) {
+    fail(`timed out waiting for ${label}\nexpected: ${expected}\nactual: ${actual}`);
+  }
   ensureFile(file, expected);
 }
 
 async function waitForFileLineCount(file, expected, label = file) {
-  await waitFor(() => {
-    if (!fs.existsSync(file)) return false;
-    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
-    return lines.length === expected;
-  }, label);
+  const deadline = Date.now() + 10000;
+  let actual = '(missing)';
+  while (Date.now() < deadline) {
+    if (fs.existsSync(file)) {
+      actual = fs.readFileSync(file, 'utf8').trim();
+      const lines = actual.split('\n').filter(Boolean);
+      if (lines.length === expected) return;
+    }
+    await sleep(100);
+  }
+  const count = actual === '(missing)' ? 0 : actual.split('\n').filter(Boolean).length;
+  fail(`timed out waiting for ${label}\nexpected lines: ${expected}\nactual lines: ${count}\nactual: ${actual}`);
 }
 
 async function waitRuntime() {
@@ -1051,6 +1089,19 @@ async function waitRuntime() {
   }, 'runtime');
 }
 
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForProcessExit(pid, label, timeoutMs = 5000) {
+  await waitFor(() => !processIsAlive(pid), label, timeoutMs);
+}
+
 async function expectWebSocketMarker(peer, marker) {
   await new Promise((resolve, reject) => {
     let sawSnapshot = false;
@@ -1077,6 +1128,21 @@ async function expectWebSocketMarker(peer, marker) {
   });
 }
 
+async function openTerminalWebSocket(peer) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(runtimeWsUrl(peer));
+    const timer = setTimeout(() => reject(new Error(`${peer} websocket open timeout`)), 5000);
+    ws.on('open', () => {
+      clearTimeout(timer);
+      resolve(ws);
+    });
+    ws.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
 async function expectResizeReplaceSnapshot(peer, marker) {
   await new Promise((resolve, reject) => {
     let sawSnapshot = false;
@@ -1150,6 +1216,197 @@ function libModuleFiles() {
     .map((name) => path.join('lib', name));
 }
 
+function assertShimRuntimeUnavailableFallback(generateShim) {
+  const fallbackDir = fs.mkdtempSync(path.join(os.tmpdir(), `hcc-shim-fallback-${testId}-`));
+  try {
+    const fakeHcc = path.join(fallbackDir, 'hcc');
+    fs.writeFileSync(fakeHcc, `#!/usr/bin/env bash
+case "\${1:-}" in
+  shim)
+    exit 64
+    ;;
+  find-root)
+    if [ -n "\${HCC_FAKE_ROOT:-}" ]; then
+      printf '%s\\n' "$HCC_FAKE_ROOT"
+      exit 0
+    fi
+    exit 1
+    ;;
+  web)
+    exit 1
+    ;;
+  peer)
+    if [ "\${2:-}" = "start" ]; then
+      printf '%s\\n' "hcc: No running web runtime found. Start hcc web first, then hcc peer start \${3:-peer}" >&2
+      exit 1
+    fi
+    exit 1
+    ;;
+esac
+exit 1
+`, { mode: 0o755 });
+
+    const cases = [
+      {
+        tool: { name: 'claude', kind: 'claude', resumeFlag: '--resume' },
+        args: ['--resume', 'missing-web-session'],
+        expected: 'real-claude --resume missing-web-session'
+      },
+      {
+        tool: { name: 'codex', kind: 'codex' },
+        args: ['resume', 'missing-web-session'],
+        expected: 'real-codex resume missing-web-session'
+      }
+    ];
+
+    for (const entry of cases) {
+      const realBin = path.join(fallbackDir, `real-${entry.tool.name}`);
+      const shimBin = path.join(fallbackDir, entry.tool.name);
+      const logFile = path.join(fallbackDir, `${entry.tool.name}.log`);
+      fs.writeFileSync(realBin, `#!/usr/bin/env bash
+printf 'real-${entry.tool.name}'
+for arg in "$@"; do printf ' %s' "$arg"; done
+printf '\\n'
+if [ -n "\${HCC_FAKE_LOG:-}" ]; then
+  printf 'real-${entry.tool.name}' >> "$HCC_FAKE_LOG"
+  for arg in "$@"; do printf ' %s' "$arg" >> "$HCC_FAKE_LOG"; done
+  printf '\\n' >> "$HCC_FAKE_LOG"
+fi
+`, { mode: 0o755 });
+      fs.writeFileSync(shimBin, generateShim(fakeHcc, realBin, entry.tool), { mode: 0o755 });
+
+      const result = runMaybe(shimBin, entry.args, {
+        cwd: fallbackDir,
+        env: {
+          ...env,
+          HCC_FAKE_ROOT: fallbackDir,
+          HCC_FAKE_LOG: logFile
+        }
+      });
+      if (result.status !== 0) {
+        fail(`${entry.tool.name} shim did not fall back when runtime was unavailable:\nstdout=${result.stdout}\nstderr=${result.stderr}`);
+      }
+      if (!String(result.stdout || '').includes(entry.expected)) {
+        fail(`${entry.tool.name} shim fallback did not launch the real provider:\nstdout=${result.stdout}\nstderr=${result.stderr}`);
+      }
+      const logOutput = fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf8') : '';
+      if (!logOutput.includes(entry.expected)) {
+        fail(`${entry.tool.name} shim fallback did not preserve provider argv:\n${logOutput}`);
+      }
+      if (String(result.stderr || '').includes('No running web runtime found')) {
+        fail(`${entry.tool.name} shim leaked hcc runtime failure instead of transparent fallback:\n${result.stderr}`);
+      }
+    }
+  } finally {
+    try { fs.rmSync(fallbackDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+async function assertShimIgnoresGlobalRuntime(generateShim) {
+  const testDir = fs.mkdtempSync(path.join(os.tmpdir(), `hcc-shim-global-runtime-${testId}-`));
+  const fakeHome = path.join(testDir, 'home');
+  const projectRoot = path.join(testDir, 'project-without-runtime');
+  const requests = [];
+  let server = null;
+  try {
+    fs.mkdirSync(path.join(fakeHome, '.hello-cc'), { recursive: true });
+    fs.mkdirSync(projectRoot, { recursive: true });
+
+    server = http.createServer((req, res) => {
+      requests.push({ method: req.method, url: req.url });
+      res.setHeader('Content-Type', 'application/json');
+      if (req.method === 'GET' && req.url.startsWith('/api/runtime')) {
+        res.end(JSON.stringify({ ok: true }));
+        return;
+      }
+      if (req.method === 'POST' && req.url.startsWith('/api/sessions')) {
+        res.end(JSON.stringify({ session: {
+          id: 'global-runtime-session',
+          kind: 'claude',
+          role: 'peer',
+          status: 'running',
+          pane: '%900'
+        } }));
+        return;
+      }
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: { code: 'NOT_FOUND', message: 'not found' } }));
+    });
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    const globalRuntime = {
+      product: 'hello-cc',
+      version: 'regression',
+      pid: process.pid,
+      root: testDir,
+      db: path.join(testDir, '.hello-cc', 'mesh.db'),
+      host: '127.0.0.1',
+      port: address.port,
+      base_url: `http://127.0.0.1:${address.port}`,
+      token: '',
+      started_at: Math.floor(Date.now() / 1000),
+      global_runtime: true
+    };
+    fs.writeFileSync(path.join(fakeHome, '.hello-cc', 'runtime.json'), JSON.stringify(globalRuntime, null, 2));
+
+    const hccWrapper = path.join(testDir, 'hcc-wrapper');
+    fs.writeFileSync(hccWrapper, `#!/usr/bin/env bash\nexec ${sh(process.execPath)} ${sh(hccBin)} "$@"\n`, { mode: 0o755 });
+
+    const cases = [
+      {
+        tool: { name: 'claude', kind: 'claude', resumeFlag: '--resume' },
+        args: ['--resume', 'global-runtime-session'],
+        expected: 'real-claude --resume global-runtime-session'
+      },
+      {
+        tool: { name: 'codex', kind: 'codex' },
+        args: ['resume', 'global-runtime-session'],
+        expected: 'real-codex resume global-runtime-session'
+      }
+    ];
+
+    for (const entry of cases) {
+      requests.length = 0;
+      fs.rmSync(path.join(projectRoot, '.hello-cc'), { recursive: true, force: true });
+      const realBin = path.join(testDir, `real-${entry.tool.name}`);
+      const shimBin = path.join(testDir, entry.tool.name);
+      fs.writeFileSync(realBin, `#!/usr/bin/env bash
+printf 'real-${entry.tool.name}'
+for arg in "$@"; do printf ' %s' "$arg"; done
+printf '\\n'
+`, { mode: 0o755 });
+      fs.writeFileSync(shimBin, generateShim(hccWrapper, realBin, entry.tool), { mode: 0o755 });
+      const result = runMaybe(shimBin, entry.args, {
+        cwd: projectRoot,
+        env: {
+          ...env,
+          HOME: fakeHome,
+          HCC_SHIM_ENSURED: '1',
+          HCC_SHIM_NO_ATTACH: '1'
+        }
+      });
+      if (result.status !== 0) {
+        fail(`${entry.tool.name} shim failed while ignoring global runtime:\nstdout=${result.stdout}\nstderr=${result.stderr}`);
+      }
+      if (!String(result.stdout || '').includes(entry.expected)) {
+        fail(`${entry.tool.name} shim used global runtime instead of falling back:\nstdout=${result.stdout}\nstderr=${result.stderr}`);
+      }
+      if (requests.length) {
+        fail(`${entry.tool.name} shim contacted global runtime despite project-local restriction:\n${JSON.stringify(requests, null, 2)}`);
+      }
+      if (fs.existsSync(path.join(projectRoot, '.hello-cc', 'mesh.db'))) {
+        fail(`${entry.tool.name} shim created a project database while only a global runtime existed`);
+      }
+    }
+  } finally {
+    if (server?.listening) await new Promise((resolve) => server.close(resolve));
+    try { fs.rmSync(testDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
 async function expectBoundedTmuxStream(label) {
   let nodes = [];
   await waitFor(() => {
@@ -1194,19 +1451,54 @@ function startRuntime(options = {}) {
   if (!output.includes('web started in background')) fail(`hcc web did not report background start:\n${output}`);
 }
 
+async function assertWebWrapperParentSurvives() {
+  const wrapperRoot = fs.mkdtempSync(path.join(os.tmpdir(), `hcc-reg-wrapper-root-${testId}-`));
+  const wrapperPort = port + 101;
+  let wrapperPid = null;
+  try {
+    const script = [
+      'set -e',
+      `out=$(${sh(process.execPath)} ${sh(hccBin)} --root ${sh(wrapperRoot)} web --local --port ${wrapperPort} --no-discover --no-guidance)`,
+      `printf '%s\\n' "$out"`
+    ].join('\n');
+    const result = runMaybe('bash', ['-lc', script], { env });
+    if (result.status !== 0) {
+      fail(`hcc web killed or failed inside a wrapper shell:\nstdout=${result.stdout}\nstderr=${result.stderr}\nstatus=${result.status}\nsignal=${result.signal}`);
+    }
+    const match = String(result.stdout || '').match(/^pid:\s*(\d+)/m);
+    if (!match) fail(`wrapper hcc web did not print background pid:\n${result.stdout}`);
+    wrapperPid = Number.parseInt(match[1], 10);
+    ensureFile(path.join(wrapperRoot, '.hello-cc', 'runtime.json'));
+  } finally {
+    runMaybe(process.execPath, [hccBin, '--root', wrapperRoot, 'down'], { env });
+    if (wrapperPid) {
+      try {
+        await waitForProcessExit(wrapperPid, 'wrapper runtime process exit', 5000);
+      } catch {
+        try { process.kill(wrapperPid, 'SIGTERM'); } catch {}
+        try { await waitForProcessExit(wrapperPid, 'wrapper runtime process exit after SIGTERM', 2000); } catch {}
+      }
+    }
+    try { fs.rmSync(wrapperRoot, { recursive: true, force: true }); } catch {}
+  }
+}
+
 async function stopRuntime() {
   if (!runtimePid) return;
+  const pid = runtimePid;
   hccMaybe(['down']);
-  await waitFor(() => {
+  try {
+    await waitForProcessExit(pid, 'runtime process exit', 5000);
+  } catch (err) {
+    try { process.kill(pid, 'SIGTERM'); } catch {}
     try {
-      process.kill(runtimePid, 0);
-      return false;
+      await waitForProcessExit(pid, 'runtime process exit after SIGTERM', 2000);
     } catch {
-      return true;
+      try { process.kill(pid, 'SIGKILL'); } catch {}
+      try { await waitForProcessExit(pid, 'runtime process exit after SIGKILL', 2000); } catch {}
+      throw err;
     }
-  }, 'runtime process exit', 5000).catch(() => {
-    try { process.kill(runtimePid, 'SIGTERM'); } catch {}
-  });
+  }
   runtimePid = null;
 }
 
@@ -1315,7 +1607,12 @@ async function setupRegression() {
     fail(`interactive bash did not keep codex shim first: ${interactiveCodex}`);
   }
   if (!hcc(['install-hooks', '--status']).includes('claude=yes codex=yes')) fail('hooks not installed');
-  if (!hcc(['shim', 'status']).includes('shims installed')) fail('shims not installed');
+  const shimStatusOutput = hcc(['shim', 'status']);
+  if (!shimStatusOutput.includes('claude: installed') ||
+      !shimStatusOutput.includes('codex: installed') ||
+      !shimStatusOutput.includes('status: complete')) {
+    fail(`shims not fully installed:\n${shimStatusOutput}`);
+  }
   const staleShim = path.join(home, '.hcc-shims', 'claude');
   fs.writeFileSync(staleShim, '#!/usr/bin/env bash\necho stale --web-managed\n', { mode: 0o755 });
   const ensured = hccMaybe(['shim', 'ensure', 'claude', staleShim]);
@@ -1326,7 +1623,27 @@ async function setupRegression() {
   if (!refreshedShim.includes('shim ensure "claude"') || refreshedShim.includes('stale --web-managed')) {
     fail(`shim ensure did not refresh stale shim:\n${refreshedShim}`);
   }
+  const deadRealBin = path.join(outDir, 'removed-claude');
+  fs.rmSync(deadRealBin, { force: true });
+  fs.writeFileSync(staleShim, [
+    '#!/usr/bin/env bash',
+    '# hello-cc shim for claude (auto-generated; do not edit manually)',
+    `# Real binary: ${deadRealBin}`,
+    `REAL_BIN=${sh(deadRealBin)}`,
+    'exec "$REAL_BIN" "$@"',
+    ''
+  ].join('\n'), { mode: 0o755 });
+  const rediscovered = hccMaybe(['shim', 'ensure', 'claude', staleShim, deadRealBin]);
+  if (rediscovered.status !== 75) {
+    fail(`shim ensure did not request re-exec for stale real binary:\n${rediscovered.stdout}\n${rediscovered.stderr}`);
+  }
+  const rediscoveredShim = fs.readFileSync(staleShim, 'utf8');
+  const expectedRealBin = path.join(fakeBin, 'claude');
+  if (!rediscoveredShim.includes(`# Real binary: ${expectedRealBin}`) || rediscoveredShim.includes(deadRealBin)) {
+    fail(`shim ensure preserved stale real binary instead of rediscovering PATH binary:\n${rediscoveredShim}`);
+  }
   await stopRuntime();
+  await assertWebWrapperParentSurvives();
   assertPeerBindingUniqueConstraints();
   assertLegacySchemaMigration();
   assertRegisteredProjectDbMigration();
@@ -1349,6 +1666,18 @@ async function setupRegression() {
   if (unauthorizedResponse.status !== 401) fail(`default web API allowed missing token: ${unauthorizedResponse.status}`);
   const tokenResponse = await runtimeFetch('/api/runtime');
   if (!tokenResponse.ok) fail(`default web API rejected runtime token: ${tokenResponse.status}`);
+  const badJsonResponse = await runtimeFetch('/api/projects', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{bad json'
+  });
+  if (badJsonResponse.status !== 400) {
+    fail(`bad JSON request returned ${badJsonResponse.status}, expected 400:\n${await badJsonResponse.text()}`);
+  }
+  const badJsonBody = await badJsonResponse.json();
+  if (badJsonBody?.error?.code !== 'BAD_REQUEST') {
+    fail(`bad JSON request did not return BAD_REQUEST:\n${JSON.stringify(badJsonBody, null, 2)}`);
+  }
   const tokenFile = path.join(home, '.hello-cc', 'web-token');
   ensureFile(tokenFile, tokenRuntime.token);
   fs.rmSync(tokenFile, { force: true });
@@ -1417,16 +1746,18 @@ async function setupRegression() {
   const childDir = path.join(root, 'packages', 'child');
   fs.mkdirSync(childDir, { recursive: true });
   const childFindRoot = hccFrom(['find-root'], childDir).trim();
-  if (childFindRoot !== childDir) fail(`child find-root mismatch: ${childFindRoot} !== ${childDir}`);
+  if (!samePath(childFindRoot, childDir)) fail(`child find-root mismatch: ${childFindRoot} !== ${childDir}`);
   const childStatus = hccFrom(['status'], childDir);
-  if (!childStatus.includes(`root: ${childDir}`) || !childStatus.includes(`db: ${path.join(childDir, '.hello-cc', 'mesh.db')}`)) {
+  if (!samePath(statusValue(childStatus, 'root'), childDir) ||
+      !samePath(statusValue(childStatus, 'db'), path.join(childDir, '.hello-cc', 'mesh.db'))) {
     fail(`child command did not stay on current path:\n${childStatus}`);
   }
   ensureFile(path.join(childDir, '.hello-cc', 'mesh.db'));
   const explicitChildRoot = hccFrom(['--root', root, 'find-root'], childDir).trim();
-  if (explicitChildRoot !== root) fail(`explicit child find-root mismatch: ${explicitChildRoot} !== ${root}`);
+  if (!samePath(explicitChildRoot, root)) fail(`explicit child find-root mismatch: ${explicitChildRoot} !== ${root}`);
   const explicitChildStatus = hccFrom(['--root', root, 'status'], childDir);
-  if (!explicitChildStatus.includes(`root: ${root}`) || !explicitChildStatus.includes(`db: ${path.join(root, '.hello-cc', 'mesh.db')}`)) {
+  if (!samePath(statusValue(explicitChildStatus, 'root'), root) ||
+      !samePath(statusValue(explicitChildStatus, 'db'), path.join(root, '.hello-cc', 'mesh.db'))) {
     fail(`explicit child command did not use requested root:\n${explicitChildStatus}`);
   }
   const childHookPayload = JSON.stringify({ session_id: 'child-hook-session', cwd: childDir, hook_event_name: 'UserPromptSubmit', prompt: 'status?' });
@@ -1565,6 +1896,38 @@ async function dbWorkflow() {
     hcc(['task', 'done', '--peer', 'batch-b', '--id', String(task.id), '--summary', 'batch next cleanup']);
   }
   hcc(['task', 'update', '--peer', 'human', '--id', batchNextIds[2], '--status', 'abandoned', '--summary', 'batch next leftover cleanup']);
+
+  const dispatched = hccJson(['task', 'dispatch', '--from', 'human', '--to', 'dispatch-a', '--title', 'dispatch new task', '--body', 'dispatch body', '--no-inject']);
+  if (!dispatched.task || dispatched.task.assignee !== 'dispatch-a' || dispatched.task.owner ||
+      dispatched.injected !== false || dispatched.injection_reason !== 'no_inject' || !dispatched.message_id) {
+    fail(`task dispatch did not create message-only assigned task:\n${JSON.stringify(dispatched, null, 2)}`);
+  }
+  const dispatchInbox = hcc(['msg', 'inbox', '--peer', 'dispatch-a', '--all']);
+  if (!dispatchInbox.includes(`task #${dispatched.task.id}`) || !dispatchInbox.includes('dispatch new task')) {
+    fail(`task dispatch durable message missing:\n${dispatchInbox}`);
+  }
+  const dispatchAudit = eventPayloads('task.dispatched', 20)
+    .find((event) => Number(event.payload?.message_id) === Number(dispatched.message_id));
+  if (!dispatchAudit ||
+      dispatchAudit.actor !== 'human' ||
+      dispatchAudit.payload.actor_peer !== 'human' ||
+      dispatchAudit.payload.target_peer !== 'dispatch-a' ||
+      dispatchAudit.payload.source !== 'cli' ||
+      dispatchAudit.payload.injected !== false ||
+      dispatchAudit.payload.injection_reason !== 'no_inject') {
+    fail(`task dispatch audit payload wrong:\n${JSON.stringify(dispatchAudit, null, 2)}`);
+  }
+  const dispatchExistingCreated = hcc(['task', 'create', '--from', 'human', '--title', 'dispatch existing task']);
+  const dispatchExistingMatch = dispatchExistingCreated.match(/created task #(\d+):/);
+  if (!dispatchExistingMatch) fail(`cannot parse dispatch existing task id: ${dispatchExistingCreated}`);
+  const dispatchExisting = hccJson(['task', 'dispatch', '--from', 'human', '--to', 'dispatch-b', '--id', dispatchExistingMatch[1], '--message', 'custom dispatch existing', '--no-inject']);
+  if (String(dispatchExisting.task?.id) !== dispatchExistingMatch[1] ||
+      dispatchExisting.task.assignee !== 'dispatch-b' ||
+      dispatchExisting.message !== 'custom dispatch existing' ||
+      dispatchExisting.injected !== false) {
+    fail(`task dispatch --id did not assign existing task:\n${JSON.stringify(dispatchExisting, null, 2)}`);
+  }
+
   const takeoverOpen = hcc(['task', 'create', '--from', 'human', '--to', 'takeover-owner', '--title', 'takeover open']);
   const takeoverOpenMatch = takeoverOpen.match(/created task #(\d+):/);
   if (!takeoverOpenMatch) fail(`cannot parse takeover open id: ${takeoverOpen}`);
@@ -1846,8 +2209,9 @@ async function multiProjectWebWorkflow() {
   fs.mkdirSync(otherRoot, { recursive: true });
   const output = hccFrom(['web', '--local', '--port', String(port), '--no-discover', '--no-guidance'], otherRoot);
   if (!output.includes('web already running in background')) fail(`second project did not reuse global web:\n${output}`);
-  if (!output.includes(`project: ${otherRoot}`)) fail(`second project output did not show its root:\n${output}`);
-  if (!output.includes(encodeURIComponent(otherRoot))) fail(`second project URL did not include project query:\n${output}`);
+  const outputRoot = statusValue(output, 'project');
+  if (!samePath(outputRoot, otherRoot)) fail(`second project output did not show its root:\n${output}`);
+  if (!output.includes(encodeURIComponent(outputRoot))) fail(`second project URL did not include project query:\n${output}`);
 
   const otherRuntimeFile = path.join(otherRoot, '.hello-cc', 'runtime.json');
   ensureFile(otherRuntimeFile);
@@ -1859,8 +2223,9 @@ async function multiProjectWebWorkflow() {
   const projectsResponse = await runtimeFetch('/api/projects', {}, { root: otherRoot });
   const projects = await projectsResponse.json();
   if (!projectsResponse.ok) fail(`projects API failed: ${JSON.stringify(projects)}`);
-  const roots = new Set((projects.projects || []).map((p) => p.root));
-  if (!roots.has(root) || !roots.has(otherRoot)) {
+  const roots = (projects.projects || []).map((p) => p.root);
+  if (!roots.some((projectRoot) => samePath(projectRoot, root)) ||
+      !roots.some((projectRoot) => samePath(projectRoot, otherRoot))) {
     fail(`projects API did not include both roots:\n${JSON.stringify(projects, null, 2)}`);
   }
 
@@ -2122,6 +2487,10 @@ async function multiProjectWebWorkflow() {
   if (!managedActionSession.action_token) {
     fail(`managed web session did not include action token:\n${JSON.stringify(managedActionSession, null, 2)}`);
   }
+  const runtimeActionToken = currentRuntime().token || '';
+  if (managedActionSession.action_token === runtimeActionToken || managedActionSession.action_token.length < 32) {
+    fail(`managed web session action token is not an independent session token:\n${JSON.stringify({ runtimeActionToken, managedActionSession }, null, 2)}`);
+  }
   const actionNext = await (await runtimeFetch(`/api/peers/${encodeURIComponent(managedActionSession.peer_id || managedActionSession.id)}/actions/task-next`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -2305,11 +2674,18 @@ async function tmuxBackedStartWorkflow() {
   await expectWebSocketInputVisible('shell-a', 'WS_INPUT_VISIBLE_OK');
   await expectBoundedTmuxStream('tmux-backed FIFO stream');
 
-  await stopRuntime();
+  const heldWs = await openTerminalWebSocket('shell-a');
+  try {
+    await stopRuntime();
+    await waitFor(() => heldWs.readyState === WebSocket.CLOSED || heldWs.readyState === WebSocket.CLOSING, 'runtime websocket close', 2000);
+  } finally {
+    try { heldWs.close(); } catch {}
+  }
   run('tmux', ['display-message', '-p', '-t', pane, '#{pane_id}']);
   startRuntime();
   await waitRuntime();
-  await waitFor(() => hcc(['peer', 'list']).includes('shell-a'), 'tmux-backed peer restore');
+  await waitFor(() => hcc(['peer', 'list']).includes('shell-a'), 'tmux-backed peer restore after websocket shutdown');
+
   const restoredFile = path.join(outDir, 'pty-restored-ok');
   hcc(['inject', 'shell-a', `echo PTY_RESTORED_OK > ${restoredFile}`]);
   await waitForFile(restoredFile, 'PTY_RESTORED_OK', 'tmux restore injection');
@@ -2401,6 +2777,10 @@ async function shimTmuxWorkflow() {
   }
 
   log('[6/13] shim tmux-backed launch');
+  if (!fs.existsSync(path.join(root, '.hello-cc', 'runtime.json'))) {
+    startRuntime();
+  }
+  await waitRuntime();
   const shim = path.join(home, '.hcc-shims', 'claude');
   const codexShim = path.join(home, '.hcc-shims', 'codex');
   const claudeVersion = run(shim, ['--version'], { cwd: root, env });
@@ -2471,6 +2851,9 @@ async function shimTmuxWorkflow() {
   const firstEnvFile = path.join(outDir, 'shim-env-first');
   hcc(['inject', peer, `printf '%s\\n' "$HCC_REG_VALUE" > ${firstEnvFile}`]);
   await waitForFile(firstEnvFile, 'shim-first', 'shim first env');
+  const shimInternalEnvFile = path.join(outDir, 'shim-internal-env');
+  hcc(['inject', peer, `printf '%s|%s|%s\\n' "\${HCC_SHIM_ENSURED-unset}" "\${HCC_SKIP_SHIM_INSTALL-unset}" "\${HCC_RUNTIME_LOCAL_ONLY-unset}" > ${shimInternalEnvFile}`]);
+  await waitForFile(shimInternalEnvFile, 'unset|unset|unset', 'shim internal env cleanup');
 
   const restarted = run(shim, ['--resume', 'shim-regression-session'], {
     cwd: root,
@@ -2492,12 +2875,34 @@ async function shimTmuxWorkflow() {
     HCC_FAKE_STAY_ALIVE: '0',
     HCC_FAKE_LOG: exitedLog
   };
-  const exitedFirst = run(shim, ['--resume', exitedResume], { cwd: root, env: exitedEnv });
+  const exitedFirstResult = runMaybe(shim, ['--resume', exitedResume], { cwd: root, env: exitedEnv });
+  if (exitedFirstResult.status !== 0) {
+    const allShimLines = fs.readFileSync(shim, 'utf8').split('\n');
+    const shimLines = allShimLines
+      .slice(0, 35)
+      .concat(['...'])
+      .concat(allShimLines.slice(139))
+      .map((line, index) => {
+        if (index < 35) return `${index + 1}: ${line}`;
+        if (index === 35) return line;
+        return `${index + 104}: ${line}`;
+      })
+      .join('\n');
+    fail(`${sh([shim, '--resume', exitedResume].join(' '))} failed\n${exitedFirstResult.stdout || ''}${exitedFirstResult.stderr || ''}\nshim excerpt:\n${shimLines}`);
+  }
+  const exitedFirst = exitedFirstResult.stdout || '';
   const exitedPeerMatch = exitedFirst.match(/started\s+(\S+)\s+\(/);
   if (!exitedPeerMatch) fail(`exited shim did not start a peer:\n${exitedFirst}`);
   const exitedPeer = exitedPeerMatch[1];
-  parsePane(exitedFirst);
-  await waitForFileLineCount(exitedLog, 1, 'shim exited first provider launch');
+  const exitedPane = parsePane(exitedFirst);
+  try {
+    await waitForFileLineCount(exitedLog, 1, 'shim exited first provider launch');
+  } catch (err) {
+    const paneCapture = runMaybe('tmux', ['capture-pane', '-p', '-S', '-80', '-t', exitedPane]);
+    const peerList = hccMaybe(['peer', 'list']);
+    const shimHead = fs.readFileSync(shim, 'utf8').split('\n').slice(0, 18).join('\n');
+    fail(`${err.message}\nshim output:\n${exitedFirst}\nshim stderr:\n${exitedFirstResult.stderr || ''}\npeer list:\n${peerList.stdout || ''}${peerList.stderr || ''}\npane ${exitedPane}:\n${paneCapture.stdout || ''}${paneCapture.stderr || ''}\nshim head:\n${shimHead}`);
+  }
   const fallbackFile = path.join(outDir, 'shim-exited-fallback');
   hcc(['inject', exitedPeer, `printf '%s\\n' fallback > ${sh(fallbackFile)}`]);
   await waitForFile(fallbackFile, 'fallback', 'shim exited fallback shell');
@@ -2546,6 +2951,16 @@ async function askBroadcastWorkflow() {
   hcc(['ask', 'shell-b', `echo ASK_OK > ${askFile}`, '--from', 'human', '--inject']);
   await waitForFile(askFile, 'ASK_OK', 'ask injection');
   if (!hcc(['msg', 'inbox', '--peer', 'shell-b', '--all']).includes('ASK_OK')) fail('ask durable message missing');
+  const shellDefaultDispatch = hccJson(['task', 'dispatch', '--from', 'human', '--to', 'shell-b', '--title', 'shell default dispatch']);
+  if (shellDefaultDispatch.injected !== false || shellDefaultDispatch.injection_reason !== 'unsupported_session_kind') {
+    fail(`task dispatch injected default natural-language prompt into shell session:\n${JSON.stringify(shellDefaultDispatch, null, 2)}`);
+  }
+  const dispatchFile = path.join(outDir, 'dispatch-ok');
+  const shellCommandDispatch = hccJson(['task', 'dispatch', '--from', 'human', '--to', 'shell-b', '--title', 'shell command dispatch', '--message', `echo DISPATCH_OK > ${dispatchFile}`, '--force']);
+  if (!shellCommandDispatch.injected || shellCommandDispatch.delivery !== 'message+inject') {
+    fail(`task dispatch did not inject explicit shell-safe message:\n${JSON.stringify(shellCommandDispatch, null, 2)}`);
+  }
+  await waitForFile(dispatchFile, 'DISPATCH_OK', 'task dispatch injection');
   const broadcastFile = path.join(outDir, 'broadcast-ok');
   hcc(['broadcast', `echo BROADCAST_OK > ${broadcastFile}`, '--from', 'human', '--inject']);
   await waitForFile(broadcastFile, 'BROADCAST_OK', 'broadcast injection');
@@ -2596,8 +3011,8 @@ async function downGcPackWorkflow() {
     "tags:\n      - 'v*'",
     'workflow_dispatch:',
     'contents: write',
-    'actions/checkout@v4',
-    'actions/setup-node@v4',
+    'actions/checkout@v5',
+    'actions/setup-node@v5',
     'node-version: 24',
     'npm run release:check',
     'npm run release:github:dry-run',
@@ -2620,16 +3035,23 @@ function oldNameScan() {
     'ACTIVE_' + 'AGENT_' + 'TTL',
     '--' + 'agent\\b'
   ].join('|');
-  const rg = runMaybe('rg', [
-    '-n',
-    '--glob', '!node_modules/**',
-    '--glob', '!*.tgz',
-    '--',
-    oldNamePattern,
-    '.'
-  ]);
-  if (rg.status === 0) fail(`old names found:\n${rg.stdout}`);
-  if (rg.status !== 1) fail(`rg failed:\n${rg.stderr || rg.stdout}`);
+  const oldNameRegex = new RegExp(oldNamePattern);
+  const files = run('git', ['ls-files'])
+    .split('\n')
+    .map((file) => file.trim())
+    .filter(Boolean)
+    .filter((file) => !file.includes('/node_modules/') && !file.endsWith('.tgz'));
+  const matches = [];
+  for (const file of files) {
+    const fullPath = path.join(repoRoot, file);
+    let content = '';
+    try { content = fs.readFileSync(fullPath, 'utf8'); } catch { continue; }
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+      if (oldNameRegex.test(lines[i])) matches.push(`${file}:${i + 1}: ${lines[i]}`);
+    }
+  }
+  if (matches.length) fail(`old names found:\n${matches.join('\n')}`);
 }
 
 function identityEnforcementWorkflow() {
@@ -3132,6 +3554,7 @@ async function syntaxAndHelp() {
     'function installShims',
     'function uninstallShims',
     'function verifyShims',
+    'function shimStatus',
     'function findRealBinary',
     'function fsExists'
   ]) {
@@ -3159,9 +3582,14 @@ async function syntaxAndHelp() {
   }
   if (!integrationShimScriptSource.includes('function generateShim') ||
       !integrationShimScriptSource.includes('hello-cc shim for ${tool.name}') ||
-      !integrationShimScriptSource.includes('HCC_SHIM_ENSURED')) {
+      !integrationShimScriptSource.includes('HCC_SHIM_ENSURED') ||
+      !integrationShimScriptSource.includes('HCC_RUNTIME_LOCAL_ONLY') ||
+      !integrationShimScriptSource.includes('hcc_runtime_unavailable_start_failure')) {
     fail('integrations shim script module is missing expected generateShim wiring');
   }
+  if (integrationShimScriptSource.includes('HCC_SKIP_SHIM_INSTALL=1 "$HCC_BIN" web')) {
+    fail('integration shim script still auto-starts hcc web instead of falling back to the real provider');
+  }
   if (!shellPathSource.includes('function installPathEntry') ||
       !shellPathSource.includes('function uninstallPathEntry') ||
       !shellPathSource.includes('.hcc-shims')) {
@@ -3184,7 +3612,7 @@ async function syntaxAndHelp() {
     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']) {
+  for (const name of ['installShims', 'uninstallShims', 'verifyShims', 'shimStatus', 'findRealBinary']) {
     if (typeof integrationShims[name] !== 'function') fail(`integrations shim module missing export: ${name}`);
     if (setupModule[name] !== integrationShims[name]) fail(`setup shim export mismatch: ${name}`);
   }
@@ -3194,10 +3622,153 @@ async function syntaxAndHelp() {
   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');
+  assertShimRuntimeUnavailableFallback(integrationShimScript.generateShim);
+  await assertShimIgnoresGlobalRuntime(integrationShimScript.generateShim);
   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 bashRc = '# regression rc\n[ -z "$PS1" ] && return\nexport PATH="/late:$PATH"\n';
+  const bashPath = shellPath.insertPathEntry(bashRc, 'bash');
+  if ((bashPath.match(/# hello-cc shims/g) || []).length !== 2 ||
+      bashPath.indexOf('# hello-cc shims (early)') > bashPath.indexOf('[ -z "$PS1" ] && return') ||
+      bashPath.lastIndexOf('# hello-cc shims (final)') < bashPath.indexOf('export PATH="/late:$PATH"')) {
+    fail(`bash shell PATH insertion lost early/final placement:\n${bashPath}`);
+  }
+  const zshPath = shellPath.insertPathEntry('export PATH="$HOME/bin:$PATH"\n', 'zsh');
+  if ((zshPath.match(/# hello-cc shims/g) || []).length !== 1 ||
+      zshPath.includes('# hello-cc shims (early)') ||
+      !zshPath.includes('# hello-cc shims (final)')) {
+    fail(`zsh shell PATH insertion should install one final entry:\n${zshPath}`);
+  }
+  const fishPath = shellPath.insertPathEntry('set -gx PATH $HOME/bin $PATH\n', 'fish');
+  if ((fishPath.match(/# hello-cc shims/g) || []).length !== 1 ||
+      fishPath.includes('# hello-cc shims (early)') ||
+      !fishPath.includes('# hello-cc shims (final)')) {
+    fail(`fish shell PATH insertion should install one final entry:\n${fishPath}`);
+  }
+  const customRc = [
+    'export PATH="$HOME/.hcc-shims:$PATH" # user custom shim dir',
+    shellPath.pathEntryLine('bash', 'final')
+  ].join('\n');
+  const cleanedRc = shellPath.removePathEntryLines(customRc);
+  if (!cleanedRc.includes('user custom shim dir') || cleanedRc.includes('# hello-cc shims')) {
+    fail(`shell PATH cleanup removed a non-hello-cc custom line or kept hello-cc line:\n${cleanedRc}`);
+  }
+  const noProviderHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-no-provider-home-'));
+  try {
+    const noProviderEnv = {
+      ...env,
+      HOME: noProviderHome,
+      PATH: '/usr/bin:/bin',
+      SHELL: '/bin/bash'
+    };
+    const noProviderInstall = run(process.execPath, [hccBin, '--root', root, 'shim', 'install'], { env: noProviderEnv });
+    if (!noProviderInstall.includes('no shims installed')) {
+      fail(`shim install without providers did not report no shims:\n${noProviderInstall}`);
+    }
+    const noProviderBashrc = path.join(noProviderHome, '.bashrc');
+    if (fs.existsSync(noProviderBashrc) && fs.readFileSync(noProviderBashrc, 'utf8').includes('.hcc-shims')) {
+      fail(`shim install without providers modified shell PATH:\n${fs.readFileSync(noProviderBashrc, 'utf8')}`);
+    }
+  } finally {
+    try { fs.rmSync(noProviderHome, { recursive: true, force: true }); } catch {}
+  }
+  const fishHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-fish-home-'));
+  try {
+    const fishEnv = {
+      ...env,
+      HOME: fishHome,
+      SHELL: '/usr/bin/fish'
+    };
+    const fishInstall = run(process.execPath, [hccBin, '--root', root, 'shim', 'install'], { env: fishEnv });
+    const fishRc = path.join(fishHome, '.config', 'fish', 'config.fish');
+    if (!fishInstall.includes('PATH updated') ||
+        !fs.existsSync(fishRc) ||
+        !fs.readFileSync(fishRc, 'utf8').includes('# hello-cc shims (final)')) {
+      fail(`fish shim install did not create config.fish PATH entry:\n${fishInstall}\n${fs.existsSync(fishRc) ? fs.readFileSync(fishRc, 'utf8') : '(missing)'}`);
+    }
+  } finally {
+    try { fs.rmSync(fishHome, { recursive: true, force: true }); } catch {}
+  }
+  const missingRcHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-missing-rc-home-'));
+  try {
+    const missingRcEnv = {
+      ...env,
+      HOME: missingRcHome,
+      SHELL: '/bin/bash'
+    };
+    const uninstallOutput = run(process.execPath, [hccBin, '--root', root, 'shim', 'uninstall'], { env: missingRcEnv });
+    if (uninstallOutput.includes('PATH entry not removed') || !uninstallOutput.includes('PATH entry not present')) {
+      fail(`shim uninstall reported missing shell rc as a failure:\n${uninstallOutput}`);
+    }
+  } finally {
+    try { fs.rmSync(missingRcHome, { recursive: true, force: true }); } catch {}
+  }
+  const partialStatusHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-partial-status-home-'));
+  try {
+    const partialStatusDir = path.join(partialStatusHome, '.hcc-shims');
+    fs.mkdirSync(partialStatusDir, { recursive: true });
+    fs.writeFileSync(path.join(partialStatusDir, 'claude'), '#!/usr/bin/env bash\nexit 0\n', { mode: 0o755 });
+    const partialStatusEnv = {
+      ...env,
+      HOME: partialStatusHome,
+      SHELL: '/bin/bash'
+    };
+    const statusOutput = run(process.execPath, [hccBin, '--root', root, 'shim', 'status'], { env: partialStatusEnv });
+    if (!statusOutput.includes('claude: installed') ||
+        !statusOutput.includes('codex: missing') ||
+        !statusOutput.includes('status: partial')) {
+      fail(`shim status did not report partial install per tool:\n${statusOutput}`);
+    }
+  } finally {
+    try { fs.rmSync(partialStatusHome, { recursive: true, force: true }); } catch {}
+  }
+  const partialShimHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-partial-shim-home-'));
+  const partialShimRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-partial-shim-root-'));
+  try {
+    const partialShimDir = path.join(partialShimHome, '.hcc-shims');
+    fs.mkdirSync(partialShimDir, { recursive: true });
+    fs.writeFileSync(path.join(partialShimDir, 'claude'), '#!/usr/bin/env bash\nexit 0\n', { mode: 0o755 });
+    const partialShimEnv = {
+      ...env,
+      HOME: partialShimHome,
+      SHELL: '/bin/bash'
+    };
+    run(process.execPath, [hccBin, '--root', partialShimRoot, 'setup', '--quiet'], { env: partialShimEnv });
+    for (const name of ['claude', 'codex']) {
+      if (!fs.existsSync(path.join(partialShimDir, name))) {
+        fail(`setup did not repair partial shim install; missing ${name}`);
+      }
+    }
+  } finally {
+    try { fs.rmSync(partialShimHome, { recursive: true, force: true }); } catch {}
+    try { fs.rmSync(partialShimRoot, { recursive: true, force: true }); } catch {}
+  }
+  const scanHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-scan-home-'));
+  const scanRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-scan-root-'));
+  try {
+    const scanRealRoot = fs.realpathSync(scanRoot);
+    const claudeSessionsDir = path.join(scanHome, '.claude', 'sessions');
+    fs.mkdirSync(claudeSessionsDir, { recursive: true });
+    fs.writeFileSync(path.join(claudeSessionsDir, 'scan-realpath.json'), JSON.stringify({
+      pid: process.pid,
+      sessionId: 'scan-realpath-session',
+      cwd: scanRoot,
+      status: 'running'
+    }));
+    const scanEnv = {
+      ...env,
+      HOME: scanHome
+    };
+    const scanOutput = run(process.execPath, [hccBin, '--root', scanRealRoot, 'scan'], { env: scanEnv });
+    if (!scanOutput.includes('claude') || !scanOutput.includes('scan-realpath')) {
+      fail(`scan did not match discovered hccRoot through realpath comparison:\n${scanOutput}`);
+    }
+  } finally {
+    try { fs.rmSync(scanHome, { recursive: true, force: true }); } catch {}
+    try { fs.rmSync(scanRoot, { recursive: true, force: true }); } catch {}
+  }
   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}`);
@@ -3588,11 +4159,12 @@ async function syntaxAndHelp() {
     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 },
-      { id: 9, type: 'web.session.stop_requested', actor: 'web', task_id: null, payload: JSON.stringify({ actor_peer: 'web', target_peer: 'peer-b', peer: 'peer-b' }), created_at: 9 }
+      { id: 9, type: 'web.session.stop_requested', actor: 'web', task_id: null, payload: JSON.stringify({ actor_peer: 'web', target_peer: 'peer-b', peer: 'peer-b' }), created_at: 9 },
+      { id: 10, type: 'task.dispatched', actor: 'peer-a', task_id: 2, payload: JSON.stringify({ actor_peer: 'peer-a', target_peer: 'peer-b', peer: 'peer-b', title: 'dispatch timeline' }), created_at: 10 }
     ]
   }, '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', 'event:9'])) {
+  if (JSON.stringify(timelineIds) !== JSON.stringify(['message:2', 'message:3', 'handoff:4', 'task:5', 'event:8', 'event:9', 'event:10'])) {
     fail(`timelineFromRows filtering/order changed: ${JSON.stringify(timelineItems)}`);
   }
   const inbound = timelineItems.find((item) => item.id === 'message:2');
@@ -5143,12 +5715,25 @@ async function syntaxAndHelp() {
   if (!taskHelp.includes('task next [--peer ID] [--force]') ||
       !taskHelp.includes('[--count N]') ||
       !taskHelp.includes('existing claimed/running/review/blocked task') ||
+      !taskHelp.includes('task dispatch --to ID --title TEXT') ||
+      !taskHelp.includes('task dispatch --to ID --id N') ||
+      !taskHelp.includes('message-only') ||
+      !taskHelp.includes('running managed Claude/Codex terminal') ||
       !taskHelp.includes('task takeover [--peer ID] --id N --reason TEXT') ||
       !taskHelp.includes('[--policy any|blocked|stale|blocked-or-stale]') ||
       !taskHelp.includes('task claim [--peer ID] --id N[,N]') ||
       !taskHelp.includes('task create --title TEXT --parent N')) {
     fail(`task help missing current-task task next semantics:\n${taskHelp}`);
   }
+  for (const expected of [
+    "if (sub === 'dispatch') return taskDispatch",
+    'async function taskDispatch(ctx, args)',
+    "addEvent(eventDb, 'task.dispatched'",
+    'function sessionLooksProviderInteractive(session)',
+    '!customMessage && !sessionLooksProviderInteractive(session)'
+  ]) {
+    if (!hccSource.includes(expected)) fail(`task dispatch source guard missing: ${expected}`);
+  }
   const teamHelp = run(process.execPath, [hccBin, 'team', '--help']);
   if (!teamHelp.includes('hcc team') || !teamHelp.includes('team plan') || !teamHelp.includes('team start') || !teamHelp.includes('team status')) {
     fail(`team help missing expected content:\n${teamHelp}`);
@@ -5177,6 +5762,19 @@ async function syntaxAndHelp() {
       !tmuxHelp.includes('deletion requires --yes')) {
     fail(`tmux help missing DB-backed gc semantics:\n${tmuxHelp}`);
   }
+  const shimHelp = run(process.execPath, [hccBin, 'shim', '--help']);
+  if (!shimHelp.includes('hcc shim') ||
+      !shimHelp.includes('shim install') ||
+      !shimHelp.includes('shim status') ||
+      !shimHelp.includes('shell PATH entry')) {
+    fail(`shim help missing maintenance command content:\n${shimHelp}`);
+  }
+  const installHooksHelp = run(process.execPath, [hccBin, 'install-hooks', '--help']);
+  if (!installHooksHelp.includes('hcc install-hooks') ||
+      !installHooksHelp.includes('install-hooks --status') ||
+      !installHooksHelp.includes('install-hooks --uninstall')) {
+    fail(`install-hooks help missing maintenance command content:\n${installHooksHelp}`);
+  }
   const gcHelp = run(process.execPath, [hccBin, 'gc', '--help']);
   if (!gcHelp.includes('hcc gc') ||
       !gcHelp.includes('gc [--older-than DAYS] [--yes]') ||
@@ -5246,11 +5844,16 @@ function uninstallWorkflow() {
   ensureFile(path.join(uninstallHome, '.claude', 'settings.json'));
   ensureFile(path.join(uninstallHome, '.codex', 'hooks.json'));
   ensureFile(path.join(uninstallHome, '.hcc-shims', 'claude'));
+  const uninstallBashrc = path.join(uninstallHome, '.bashrc');
+  if (!fs.readFileSync(uninstallBashrc, 'utf8').includes('.hcc-shims')) {
+    fail('setup did not install shim PATH entry before uninstall workflow');
+  }
 
   const kept = run(process.execPath, [hccBin, '--root', uninstallRoot, 'uninstall'], { env: uninstallEnv });
   if (!kept.includes('project data kept')) fail(`uninstall did not keep project data by default:\n${kept}`);
   if (!fs.existsSync(path.join(uninstallRoot, '.hello-cc', 'mesh.db'))) fail('default uninstall removed project db');
   if (fs.existsSync(path.join(uninstallHome, '.hcc-shims', 'claude'))) fail('default uninstall did not remove shim');
+  if (fs.readFileSync(uninstallBashrc, 'utf8').includes('.hcc-shims')) fail('default uninstall did not remove shim PATH entry');
   if (!run(process.execPath, [hccBin, '--root', uninstallRoot, 'install-hooks', '--status'], { env: uninstallEnv }).includes('claude=no codex=no')) {
     fail('default uninstall did not remove hooks');
   }