sneakoscope 0.7.74 → 0.7.78

package/README.md

@@ -150,11 +150,12 @@ For [codex-lb](https://github.com/Soju06/codex-lb), start the server, create a d
 
 ```sh
 sks codex-lb setup --host https://your-codex-lb.example.com --api-key "sk-clb-..."
+sks codex-lb health
 sks codex-lb repair
 sks
 ```
 
-Bare `sks` can also prompt for codex-lb auth; SKS stores the base URL/key in `~/.codex/sks-codex-lb.env`, syncs `codex login --with-api-key`, and loads it in tmux.
+Bare `sks` can also prompt for codex-lb auth; SKS stores the base URL/key in `~/.codex/sks-codex-lb.env`, syncs `codex login --with-api-key`, and loads it in tmux. When codex-lb is active, SKS opens a fresh `sks-codex-lb-*` tmux session and sweeps older detached codex-lb sessions for the same repo before launch so stale Responses API chains are not reused. Configured launch paths, including non-interactive runs, verify that codex-lb can continue a Responses API chain with `previous_response_id`; if that check fails, SKS bypasses codex-lb for that launch with `model_provider="openai"` instead of letting the Codex session fail mid-work.
 
 If Codex CLI auth drifts after launch/reinstall, run `sks doctor --fix` or `sks codex-lb repair`; to replace it, run `sks codex-lb reconfigure --host <domain> --api-key <key>`.
 
@@ -278,6 +279,8 @@ Default setup adds these generated SKS paths to the project `.gitignore`; `--loc
 
 Use `sks dollar-commands` to confirm that terminal discovery and Codex App prompt commands agree.
 
+SKS does not install Git pre-commit hooks. Release metadata is changed only by explicit commands such as `sks versioning bump`, and `sks versioning hook` is intentionally blocked so Codex App commit/push flows stay unobstructed.
+
 TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks harness fixture` validates the broader Harness Growth Factory contract: deliberate forgetting fixtures, skill card metadata, experiment schema, tool-error taxonomy, permission profiles, MultiAgentV2 defaults, and tmux cockpit view coverage. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
 
 ## OpenClaw Agent Usage
@@ -416,6 +419,8 @@ npm run publish:dry
 
 `release:check` runs audit, changelog, syntax, selftest, size, and registry checks. `publish:dry` runs that same gate and then performs an npm dry-run publish against the public registry.
 
+Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
+
 ## License
 
 MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.74",
+  "version": "0.7.78",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Goal, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/src/cli/install-helpers.mjs

@@ -217,6 +217,126 @@ export async function codexLbStatus(opts = {}) {
   };
 }
 
+function codexLbResponsesEndpoint(baseUrl = '') {
+  const base = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!base) return '';
+  return /\/responses$/i.test(base) ? base : `${base}/responses`;
+}
+
+function codexLbChainCheckEnabled(env = process.env) {
+  return env.SKS_CODEX_LB_CHAIN_CHECK !== '0' && env.SKS_SKIP_CODEX_LB_CHAIN_CHECK !== '1';
+}
+
+function isPreviousResponseNotFound(payload = {}) {
+  const error = payload?.error || payload?.response?.error || payload;
+  const text = typeof error === 'string'
+    ? error
+    : [error?.type, error?.code, error?.message, error?.param, JSON.stringify(error || {})].filter(Boolean).join(' ');
+  return /previous_response_not_found|previous_response_id.*not found|previous_response_id/i.test(text);
+}
+
+function parseCodexLbSseEvents(text = '') {
+  const events = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    if (!line.startsWith('data:')) continue;
+    const data = line.slice(5).trim();
+    if (!data || data === '[DONE]') continue;
+    try {
+      events.push(JSON.parse(data));
+    } catch {}
+  }
+  return events;
+}
+
+function codexLbResponseId(payload = {}) {
+  if (typeof payload?.id === 'string' && payload.id) return payload.id;
+  if (typeof payload?.response?.id === 'string' && payload.response.id) return payload.response.id;
+  if (typeof payload?.data?.id === 'string' && payload.data.id) return payload.data.id;
+  if (typeof payload?.data?.response?.id === 'string' && payload.data.response.id) return payload.data.response.id;
+  return null;
+}
+
+function codexLbResponseError(json, events = []) {
+  if (json?.error) return json;
+  for (const event of events) {
+    if (event?.error || event?.response?.error || event?.type === 'response.failed' || event?.type === 'error') return event;
+  }
+  return null;
+}
+
+async function fetchCodexLbResponse(fetchImpl, endpoint, apiKey, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs).unref?.();
+  try {
+    const response = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    const text = await response.text();
+    let json = null;
+    try { json = text ? JSON.parse(text) : null; } catch {}
+    const events = json ? [] : parseCodexLbSseEvents(text);
+    const responseId = codexLbResponseId(json) || events.map((event) => codexLbResponseId(event)).find(Boolean) || null;
+    const errorPayload = codexLbResponseError(json, events);
+    return { ok: response.ok && !errorPayload, status: response.status, json, text, events, response_id: responseId, error_payload: errorPayload };
+  } catch (err) {
+    return { ok: false, status: 0, json: null, text: err.name === 'AbortError' ? 'request timed out' : err.message, events: [], response_id: null, error_payload: null };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function checkCodexLbResponseChain(status = {}, opts = {}) {
+  const env = opts.env || process.env;
+  if (!codexLbChainCheckEnabled(env) && !opts.force) return { ok: true, status: 'skipped', skipped: true, reason: 'SKS_CODEX_LB_CHAIN_CHECK=0' };
+  const endpoint = codexLbResponsesEndpoint(opts.baseUrl || status.base_url);
+  if (!endpoint) return { ok: false, status: 'missing_base_url', chain_unhealthy: true };
+  const apiKey = opts.apiKey || parseCodexLbEnvKey(await readText(opts.envPath || status.env_path || codexLbEnvPath(opts.home || env.HOME || os.homedir()), ''));
+  if (!apiKey) return { ok: false, status: 'missing_env_key', chain_unhealthy: true };
+  const fetchImpl = opts.fetch || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return { ok: true, status: 'skipped', skipped: true, reason: 'fetch unavailable' };
+  const model = opts.model || env.SKS_CODEX_MODEL || 'gpt-5.5';
+  const timeoutMs = Number(opts.timeoutMs || env.SKS_CODEX_LB_CHAIN_CHECK_TIMEOUT_MS || 8000);
+  const baseBody = {
+    model,
+    instructions: 'You are running a short SKS codex-lb response-chain health check.',
+    input: 'SKS codex-lb response-chain health check. Reply with OK.',
+    stream: true,
+    store: true,
+    parallel_tool_calls: false,
+    tool_choice: 'auto',
+    reasoning: { effort: 'low' }
+  };
+  const first = await fetchCodexLbResponse(fetchImpl, endpoint, apiKey, baseBody, timeoutMs);
+  if (!first.ok || !first.response_id) {
+    return {
+      ok: false,
+      status: first.ok ? 'missing_response_id' : 'first_request_failed',
+      chain_unhealthy: true,
+      endpoint,
+      http_status: first.status,
+      error: redactSecretText(first.error_payload?.error?.message || first.error_payload?.response?.error?.message || first.text || 'codex-lb first Responses request failed', [apiKey])
+    };
+  }
+  const second = await fetchCodexLbResponse(fetchImpl, endpoint, apiKey, { ...baseBody, previous_response_id: first.response_id }, timeoutMs);
+  if (second.ok) return { ok: true, status: 'chain_ok', endpoint, response_id: first.response_id, chained_response_id: second.response_id || null, http_status: second.status };
+  const previousMissing = isPreviousResponseNotFound(second.error_payload || second.json || second.text);
+  return {
+    ok: false,
+    status: previousMissing ? 'previous_response_not_found' : 'second_request_failed',
+    chain_unhealthy: true,
+    endpoint,
+    response_id: first.response_id,
+    http_status: second.status,
+    error: redactSecretText(second.error_payload?.error?.message || second.error_payload?.response?.error?.message || second.text || 'codex-lb chained Responses request failed', [apiKey])
+  };
+}
+
 function hasTopLevelCodexLbSelected(text = '') {
   const topLevel = String(text || '').split(/\n\s*\[/)[0] || '';
   return /(^|\n)\s*model_provider\s*=\s*"codex-lb"\s*(?:#.*)?(?=\n|$)/.test(topLevel);
@@ -283,13 +403,18 @@ export async function ensureCodexLbAuthDuringInstall(opts = {}) {
 
 export async function maybePromptCodexLbSetupForLaunch(args = [], opts = {}) {
   if (args.includes('--json') || args.includes('--skip-codex-lb') || process.env.SKS_SKIP_CODEX_LB_PROMPT === '1') return { status: 'skipped' };
-  if (!canAskYesNo()) return { status: 'non_interactive' };
   const status = await codexLbStatus(opts);
   if (status.ok) {
     const codexLogin = await ensureCodexLbLoginFromEnv(status, opts);
     if (codexLogin.status === 'synced') console.log('codex-lb auth synced with Codex CLI.');
-    return { status: 'present', ...status, codex_login: codexLogin };
+    const chainHealth = await checkCodexLbResponseChain(status, opts);
+    if (!chainHealth.ok && chainHealth.chain_unhealthy) {
+      console.log(`codex-lb response chain check failed (${chainHealth.status}); bypassing codex-lb for this launch.`);
+      return { status: 'chain_unhealthy', ...status, ok: false, codex_login: codexLogin, chain_health: chainHealth, bypass_codex_lb: true };
+    }
+    return { status: 'present', ...status, codex_login: codexLogin, chain_health: chainHealth };
   }
+  if (!canAskYesNo()) return { status: 'non_interactive', codex_lb: status };
   const useCodexLb = (await askPostinstallQuestion('\nAuthenticate and route Codex through codex-lb? [y/N] ')).trim();
   if (!/^(y|yes|예|네|응)$/i.test(useCodexLb)) return { status: 'continued_to_codex' };
   const host = (await askPostinstallQuestion('codex-lb host domain [http://127.0.0.1:2455]: ')).trim() || 'http://127.0.0.1:2455';
@@ -1110,6 +1235,56 @@ export async function selftestCodexLb(tmp) {
   if (codexLbNotConfigured.code !== 0 || String(codexLbNotConfigured.stdout || '').includes('codex-lb auth:')) throw new Error('selftest: postinstall should stay quiet when codex-lb is not configured');
   const codexLbStatusText = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'codex-lb', 'status'], { cwd: tmp, env: codexLbEnvForSelftest, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
   if (!String(codexLbStatusText.stdout || '').includes('Repair auth: sks codex-lb repair')) throw new Error('selftest: codex-lb status did not advertise repair command');
+  const nonInteractiveLaunchChainCalls = [];
+  const nonInteractiveLaunch = await maybePromptCodexLbSetupForLaunch([], {
+    home: codexLbHome,
+    apiKey: 'sk-test',
+    codexBin: path.join(codexLbFakeBin, 'codex'),
+    timeoutMs: 1000,
+    fetch: async (url, init) => {
+      nonInteractiveLaunchChainCalls.push({ url, body: JSON.parse(init.body) });
+      return new Response(JSON.stringify({ id: nonInteractiveLaunchChainCalls.length === 1 ? 'resp_noninteractive_1' : 'resp_noninteractive_2' }), { status: 200, headers: { 'content-type': 'application/json' } });
+    }
+  });
+  if (!nonInteractiveLaunch.ok || nonInteractiveLaunch.status !== 'present' || nonInteractiveLaunch.chain_health?.status !== 'chain_ok' || nonInteractiveLaunchChainCalls.length !== 2 || nonInteractiveLaunchChainCalls[1].body.previous_response_id !== 'resp_noninteractive_1') throw new Error('selftest: non-interactive codex-lb launch path did not run response-chain preflight');
+  const nonInteractiveBrokenLaunch = await maybePromptCodexLbSetupForLaunch([], {
+    home: codexLbHome,
+    apiKey: 'sk-test',
+    codexBin: path.join(codexLbFakeBin, 'codex'),
+    timeoutMs: 1000,
+    fetch: async (_url, init) => {
+      const body = JSON.parse(init.body);
+      if (!body.previous_response_id) return new Response(JSON.stringify({ id: 'resp_noninteractive_broken' }), { status: 200, headers: { 'content-type': 'application/json' } });
+      return new Response(JSON.stringify({ error: { type: 'invalid_request_error', code: 'previous_response_not_found', message: 'Previous response not found.', param: 'previous_response_id' } }), { status: 400, headers: { 'content-type': 'application/json' } });
+    }
+  });
+  if (nonInteractiveBrokenLaunch.status !== 'chain_unhealthy' || nonInteractiveBrokenLaunch.bypass_codex_lb !== true || nonInteractiveBrokenLaunch.chain_health?.status !== 'previous_response_not_found') throw new Error('selftest: non-interactive codex-lb launch path did not bypass on previous_response_not_found');
+  const chainCalls = [];
+  const okChain = await checkCodexLbResponseChain(
+    { base_url: 'https://lb.example.test/backend-api/codex', env_path: path.join(codexLbHome, '.codex', 'sks-codex-lb.env') },
+    {
+      apiKey: 'sk-test',
+      timeoutMs: 1000,
+      fetch: async (url, init) => {
+        chainCalls.push({ url, body: JSON.parse(init.body) });
+        return new Response(JSON.stringify({ id: chainCalls.length === 1 ? 'resp_selftest_1' : 'resp_selftest_2' }), { status: 200, headers: { 'content-type': 'application/json' } });
+      }
+    }
+  );
+  if (!okChain.ok || okChain.status !== 'chain_ok' || chainCalls.length !== 2 || !String(chainCalls[0].url).endsWith('/backend-api/codex/responses') || chainCalls[1].body.previous_response_id !== 'resp_selftest_1') throw new Error('selftest: codex-lb response chain health check did not verify previous_response_id continuity');
+  const brokenChain = await checkCodexLbResponseChain(
+    { base_url: 'https://lb.example.test/backend-api/codex', env_path: path.join(codexLbHome, '.codex', 'sks-codex-lb.env') },
+    {
+      apiKey: 'sk-test',
+      timeoutMs: 1000,
+      fetch: async (_url, init) => {
+        const body = JSON.parse(init.body);
+        if (!body.previous_response_id) return new Response(JSON.stringify({ id: 'resp_missing_selftest' }), { status: 200, headers: { 'content-type': 'application/json' } });
+        return new Response(JSON.stringify({ error: { type: 'invalid_request_error', code: 'previous_response_not_found', message: 'Previous response not found.', param: 'previous_response_id' } }), { status: 400, headers: { 'content-type': 'application/json' } });
+      }
+    }
+  );
+  if (brokenChain.ok || brokenChain.status !== 'previous_response_not_found' || brokenChain.chain_unhealthy !== true) throw new Error('selftest: codex-lb response chain health check did not detect previous_response_not_found');
   if (!/^model = "gpt-5\.5"/m.test(codexLbConfig) || !codexLbConfig.includes('service_tier = "fast"') || !codexLbConfig.includes('hooks = true') || hasDeprecatedCodexHooksFeatureFlag(codexLbConfig) || !codexLbConfig.includes('multi_agent = true') || !codexLbConfig.includes('fast_mode = true') || !codexLbConfig.includes('fast_mode_ui = true') || !codexLbConfig.includes('codex_git_commit = true') || !codexLbConfig.includes('computer_use = true') || !codexLbConfig.includes('apps = true') || !codexLbConfig.includes('plugins = true') || !codexLbConfig.includes('[user.fast_mode]') || !codexLbConfig.includes('visible = true') || !codexLbConfig.includes('enabled = true') || !codexLbConfig.includes('default_profile = "sks-fast-high"') || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(codexLbConfig) || codexLbConfig.includes('fast_default_opt_out = true') || hasTopLevelCodexModeLock(codexLbConfig)) throw new Error('selftest: codex-lb setup did not preserve Codex App feature flags, Fast mode defaults, Codex Git commit generation, force GPT-5.5, or migrate the hooks feature flag');
   if (!hasCodexUnstableFeatureWarningSuppression(codexLbConfig)) throw new Error('selftest: codex-lb setup did not suppress Codex unstable feature warning');
   const codexLbLaunch = codexLaunchCommand(tmp, 'codex', []);
@@ -1117,7 +1292,7 @@ export async function selftestCodexLb(tmp) {
   if (!codexLbLaunch.includes("'--model' 'gpt-5.5'")) throw new Error('selftest: tmux launch command without args did not force GPT-5.5');
   if (!codexLbLaunch.includes('SKS_TMUX_LOGO_ANIMATION') || !codexLbLaunch.includes('SNEAKOSCOPE CODEX')) throw new Error('selftest: tmux launch command does not include the animated SKS logo intro');
   const madLaunchSource = await safeReadText(path.join(packageRoot(), 'src', 'cli', 'maintenance-commands.mjs'));
-  if (!madLaunchSource.includes('const lb = await deps.maybePromptCodexLbSetupForLaunch(args)') || !madLaunchSource.includes("const launchLb = lb.status === 'present'") || !madLaunchSource.includes('codexLbImmediateLaunchOpts(cleanArgs, launchLb')) throw new Error('selftest: MAD launch does not sync codex-lb auth and fresh-session launch options');
+  if (!madLaunchSource.includes('const lb = await deps.maybePromptCodexLbSetupForLaunch(args)') || !madLaunchSource.includes("const launchLb = lb.status === 'present'") || !madLaunchSource.includes('codexLbImmediateLaunchOpts(cleanArgs, launchLb') || !madLaunchSource.includes('bypass_codex_lb') || !madLaunchSource.includes('model_provider="openai"') || !madLaunchSource.includes('codexLbFreshSession: true')) throw new Error('selftest: MAD launch does not sync codex-lb auth and fresh-session launch options');
 
 }
 

package/src/cli/main.mjs

@@ -18,7 +18,7 @@ import { classifySql, classifyCommand, classifyToolPayload, checkDbOperation, ha
 import { checkHarnessModification, harnessGuardStatus, isHarnessSourceProject } from '../core/harness-guard.mjs';
 import { formatHarnessConflictReport, llmHarnessCleanupPrompt, scanHarnessConflicts } from '../core/harness-conflicts.mjs';
 import { context7Docs, context7Resolve, context7Text, context7Tools } from '../core/context7-client.mjs';
-import { bumpProjectVersion, installVersionGitHook, runVersionPreCommit, versioningStatus } from '../core/version-manager.mjs';
+import { bumpProjectVersion, disableVersionGitHook, runVersionPreCommit, versioningStatus } from '../core/version-manager.mjs';
 import { rustInfo } from '../core/rust-accelerator.mjs';
 import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../core/gx-renderer.mjs';
 import { defaultEvaluationScenario, runEvaluationBenchmark } from '../core/evaluation.mjs';
@@ -75,10 +75,10 @@ import { GOAL_WORKFLOW_ARTIFACT } from '../core/goal-workflow.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
 import { codexAppRemoteControlCommand } from './codex-app-command.mjs';
 import { OPENCLAW_SKILL_NAME, installOpenClawSkill } from '../core/openclaw.mjs';
-import { buildTmuxLaunchPlan, buildTmuxOpenArgs, codexLaunchCommand, createTmuxSession, defaultCodexLaunchArgs, isTmuxShellSession, runTmuxLaunchPlanSyntaxCheck, shouldAutoAttachTmux, sksAsciiLogo, tmuxReadiness, tmuxStatusKind, defaultTmuxSessionName, formatTmuxBanner, launchMadTmuxUi, launchTmuxTeamView, launchTmuxUi, platformTmuxInstallHint, reconcileTmuxTeamCockpit, runTmuxStatus, sanitizeTmuxSessionName, teamLaneStyle } from '../core/tmux-ui.mjs';
+import { buildTmuxLaunchPlan, buildTmuxOpenArgs, codexLaunchCommand, createTmuxSession, defaultCodexLaunchArgs, isTmuxShellSession, runTmuxLaunchPlanSyntaxCheck, shouldAutoAttachTmux, sksAsciiLogo, tmuxReadiness, tmuxStatusKind, defaultTmuxSessionName, formatTmuxBanner, launchMadTmuxUi, launchTmuxTeamView, launchTmuxUi, platformTmuxInstallHint, reconcileTmuxTeamCockpit, runTmuxStatus, sanitizeTmuxSessionName, sweepCodexLbTmuxSessions, sweepTmuxTeamSurfaces, teamLaneStyle } from '../core/tmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 import { context7Command } from './context7-command.mjs';
-import { askPostinstallQuestion, checkContext7, checkRequiredSkills, codexLbStatus, configureCodexLb, ensureCodexCliTool, ensureGlobalCodexFastModeDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureRelatedCliTools, ensureSksCommandDuringInstall, ensureTmuxCliTool, globalCodexSkillsRoot, maybePromptCodexLbSetupForLaunch, maybePromptCodexUpdateForLaunch, postinstall, postinstallBootstrapDecision, repairCodexLbAuth, selftestCodexLb, shouldAutoApproveInstall } from './install-helpers.mjs';
+import { askPostinstallQuestion, checkCodexLbResponseChain, checkContext7, checkRequiredSkills, codexLbStatus, configureCodexLb, ensureCodexCliTool, ensureGlobalCodexFastModeDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureRelatedCliTools, ensureSksCommandDuringInstall, ensureTmuxCliTool, globalCodexSkillsRoot, maybePromptCodexLbSetupForLaunch, maybePromptCodexUpdateForLaunch, postinstall, postinstallBootstrapDecision, repairCodexLbAuth, selftestCodexLb, shouldAutoApproveInstall } from './install-helpers.mjs';
 import { buildTeamPlan, codeStructureCommand, dbCommand, defaultBeta, defaultVGraph, evalCommand, gcCommand, goalCommand, gxCommand, harnessCommand, hproofCommand, madHighCommand as runMadHighCommand, memoryCommand, migrateWikiContextPack, parseTeamCreateArgs, perfCommand, profileCommand, projectWikiClaims, proofFieldCommand, qaLoopCommand, quickstartCommand, researchCommand, skillDreamCommand, statsCommand, team, teamWorkflowMarkdown, validateArtifactsCommand, wikiCommand, wikiVoxelRowCount, writeWikiContextPack } from './maintenance-commands.mjs';
 import { openClawCommand } from './openclaw-command.mjs';
 
@@ -144,13 +144,20 @@ async function defaultTmuxCommand(args = []) {
 }
 
 function codexLbImmediateLaunchOpts(args = [], lb = {}, opts = {}) {
-  if (!lb?.ok || lb.status !== 'configured') return opts;
-  if (readOption(args, '--session', null) || readOption(args, '--workspace', null)) return opts;
   const root = readOption(args, '--root', process.cwd());
+  const explicitSession = readOption(args, '--session', null) || readOption(args, '--workspace', null);
+  if (lb?.bypass_codex_lb) {
+    const session = explicitSession || sanitizeTmuxSessionName(`sks-openai-fallback-${Date.now().toString(36)}-${defaultTmuxSessionName(root)}`);
+    console.log(`codex-lb bypass active for this launch: ${lb.chain_health?.status || lb.status}`);
+    console.log(`Using fresh OpenAI fallback tmux session: ${session}`);
+    return { ...opts, session, codexArgs: [...(opts.codexArgs || []), '-c', 'model_provider="openai"'], codexLbBypassed: true };
+  }
+  if (!lb?.ok) return opts;
+  if (explicitSession) return opts;
   const session = sanitizeTmuxSessionName(`sks-codex-lb-${Date.now().toString(36)}-${defaultTmuxSessionName(root)}`);
-  console.log(`codex-lb key loaded for this launch: ${lb.env_path}`);
+  console.log(`codex-lb active for this launch: ${lb.env_path || lb.base_url || 'configured'}`);
   console.log(`Using fresh tmux session: ${session}`);
-  return { ...opts, session };
+  return { ...opts, session, codexLbFreshSession: true };
 }
 
 function help(args = []) {
@@ -171,8 +178,8 @@ Usage:
   sks bootstrap [--install-scope global|project] [--local-only] [--json]
   sks deps check|install [tmux|codex|context7|all] [--yes] [--json]
   sks codex-app
-  sks codex-lb status|repair|setup --host <domain> --api-key <key>
-  sks auth status|repair|setup --host <domain> --api-key <key>
+  sks codex-lb status|health|repair|setup --host <domain> --api-key <key>
+  sks auth status|health|repair|setup --host <domain> --api-key <key>
   sks openclaw install|path|print [--dir path] [--force] [--json]
   sks --mad [--high]
   sks auto-review status|enable|start [--high]
@@ -192,7 +199,7 @@ Usage:
   sks pipeline answer <mission-id|latest> <answers.json|--stdin|--text "...">
   sks guard check [--json]
   sks conflicts check|prompt [--json]
-  sks versioning status|bump|pre-commit [--json]
+  sks versioning status|bump|disable [--json]
   sks reasoning ["prompt"] [--json]
   sks aliases
   sks setup [--bootstrap] [--install-scope global|project] [--local-only] [--force] [--json]
@@ -1002,10 +1009,19 @@ async function versioning(sub = 'status', args = []) {
     if (!status.ok) console.log('Run: sks doctor --fix');
     return;
   }
-  if (action === 'hook' || action === 'install-hook') {
-    const res = await installVersionGitHook(root, await globalSksCommand());
+  if (action === 'hook' || action === 'install-hook' || action === 'enable') {
+    const res = await disableVersionGitHook(root);
+    const blocked = { ...res, ok: false, installed: false, reason: 'pre_commit_hooks_unsupported' };
+    process.exitCode = 2;
+    if (flag(args, '--json')) return console.log(JSON.stringify(blocked, null, 2));
+    console.error('SKS no longer installs Git pre-commit hooks. Use `sks versioning bump` and release checks explicitly.');
+    if (res.hook_removed) console.error(`Removed existing SKS version hook: ${res.hook_path}`);
+    return;
+  }
+  if (action === 'disable' || action === 'off' || action === 'remove-hook' || action === 'unhook') {
+    const res = await disableVersionGitHook(root);
     if (flag(args, '--json')) return console.log(JSON.stringify(res, null, 2));
-    console.log(res.installed ? `Version hook installed: ${res.hook_path}` : `Version hook skipped: ${res.reason}`);
+    console.log(res.hook_removed ? `Version hook removed: ${res.hook_path}` : `Version hook disabled: ${res.reason || 'policy updated'}`);
     return;
   }
   if (action === 'bump') {
@@ -1032,7 +1048,7 @@ async function versioning(sub = 'status', args = []) {
     console.log(res.changed ? `SKS versioning synced: ${res.version}` : `SKS versioning: ${res.version} verified`);
     return;
   }
-  console.error('Usage: sks versioning status|bump|pre-commit [--json]');
+  console.error('Usage: sks versioning status|bump|disable [--json]');
   process.exitCode = 1;
 }
 
@@ -1125,6 +1141,21 @@ async function codexLbCommand(action = 'status', args = []) {
     else console.log('\nRepair auth: sks codex-lb repair');
     return;
   }
+  if (sub === 'health' || sub === 'verify-chain' || sub === 'chain') {
+    const status = await codexLbStatus();
+    const result = status.ok
+      ? await checkCodexLbResponseChain(status, { force: true })
+      : { ok: false, status: 'not_configured', codex_lb: status };
+    if (json) return console.log(JSON.stringify(result, null, 2));
+    if (result.ok) {
+      console.log('codex-lb response chain: ok');
+      return;
+    }
+    console.error(`codex-lb response chain: failed (${result.status})`);
+    if (result.error) console.error(result.error);
+    process.exitCode = 1;
+    return;
+  }
   if (sub === 'repair' || sub === 'resync' || sub === 'login') {
     const result = await repairCodexLbAuth();
     if (json) return console.log(JSON.stringify(result, null, 2));
@@ -1160,7 +1191,7 @@ async function codexLbCommand(action = 'status', args = []) {
     console.log(`Key env: ${result.env_path}`);
     return;
   }
-  console.error('Usage: sks codex-lb status|repair|setup --host <domain> --api-key <key> [--json]');
+  console.error('Usage: sks codex-lb status|health|repair|setup --host <domain> --api-key <key> [--json]');
   process.exitCode = 1;
 }
 
@@ -1448,7 +1479,7 @@ function usage(args = []) {
   const topic = String(args[0] || 'overview').toLowerCase();
   const blocks = {
     overview: [sksAsciiLogo(), '', 'Usage', '', 'Discover:', '  sks commands', '  sks quickstart', '  sks root', '  sks bootstrap', '  sks deps check', '  sks codex-app check', '  sks tmux check', '  sks dollar-commands', '', `Topics: ${USAGE_TOPICS}`],
-    install: ['Install', '', '1. Global install:', '  npm i -g sneakoscope', '', '2. Bootstrap and check dependencies:', '  sks bootstrap', '  sks deps check', '', '3. Confirm Codex App commands:', '  sks codex-app check', '  sks dollar-commands', '', '4. Optional codex-lb key setup for CLI sks runs:', '  sks codex-lb setup --host <domain> --api-key <key>', '  sks codex-lb repair', '  sks', '', 'Fallback:', '  npx -y -p sneakoscope sks root', '', 'Project:', '  npm i -D sneakoscope', '  npx sks setup --install-scope project'],
+    install: ['Install', '', '1. Global install:', '  npm i -g sneakoscope', '', '2. Bootstrap and check dependencies:', '  sks bootstrap', '  sks deps check', '', '3. Confirm Codex App commands:', '  sks codex-app check', '  sks dollar-commands', '', '4. Optional codex-lb key setup for CLI sks runs:', '  sks codex-lb setup --host <domain> --api-key <key>', '  sks codex-lb health', '  sks codex-lb repair', '  sks', '', 'Fallback:', '  npx -y -p sneakoscope sks root', '', 'Project:', '  npm i -D sneakoscope', '  npx sks setup --install-scope project'],
     bootstrap: ['Bootstrap', '', '  sks bootstrap', '  sks setup --bootstrap', '', 'Creates project SKS files, Codex App skills/hooks/config, state/guard files, then checks Codex App, Context7, and tmux.'],
     root: ['Root', '', '  sks root [--json]', '', 'Inside a project, SKS uses that project root. Outside any project marker, runtime commands use the per-user global SKS root instead of writing .sneakoscope into the current random folder.'],
     deps: ['Dependencies', '', '  sks deps check [--json]', '  sks deps install [tmux|codex|context7|all] [--yes]', '', 'tmux on macOS uses Homebrew after Y/n approval for missing installs or Homebrew-managed upgrades. If PATH resolves an npm-managed tmux, SKS prompts for npm i -g tmux@latest instead. Unknown non-Homebrew tmux paths are reported as conflicts.'],
@@ -1598,7 +1629,7 @@ async function setup(args) {
   console.log(`Install:   ${install.ok ? 'ok' : 'missing'} ${install.scope} (${install.command_prefix})`);
   console.log(`CLI tools: Codex ${formatCodexCliToolStatus(cliTools.codex)}; tmux ${tmuxStatusKind(cliTools.tmux)} ${cliTools.tmux.version || cliTools.tmux.error || ''}`.trimEnd());
   console.log(`Hooks:     ${path.relative(root, hooksPath)}`);
-  console.log(`Version:   ${versioningInfo.enabled ? (versioningInfo.hook_installed ? 'auto-bump enabled' : 'auto-bump hook missing') : 'not enabled'}${versioningInfo.package_version ? ` (${versioningInfo.package_version})` : ''}`);
+  console.log(`Version:   explicit bump only${versioningInfo.package_version ? ` (${versioningInfo.package_version})` : ''}`);
   if (localOnly) console.log('Git:       local-only (.git/info/exclude; user AGENTS preserved, SKS managed block refreshed)');
   else console.log('Git:       .gitignore ignores SKS generated files');
   console.log(`Codex App: .codex/config.toml, .codex/hooks.json, .agents/skills, .codex/agents, .codex/SNEAKOSCOPE.md`);
@@ -1764,7 +1795,7 @@ async function doctor(args) {
   if (!appRuntime.ok) console.log('Codex App or first-party MCP/plugin tools missing. Run: sks codex-app check');
   if (!result.runtime.tmux.ok) console.log('tmux missing. Run: sks deps install tmux');
   if (!result.harness_guard.ok) console.log('Harness guard failed. Run: sks setup from a real terminal, then sks guard check.');
-  if (!result.versioning.ok) console.log('Versioning hook missing. Run: sks versioning hook, or sks doctor --fix.');
+  if (!result.versioning.ok) console.log('Versioning metadata drift detected. Run: sks versioning status, then sks versioning bump if release metadata should change.');
   if (!result.codex_lb.ready) console.log('codex-lb config/auth drift detected. Run: sks doctor --fix, or reconfigure once with sks codex-lb reconfigure --host <domain> --api-key <key>.');
   if (!result.skills.ok) console.log(`Missing skills: ${result.skills.missing.join(', ')}. Run: sks setup`);
   if (!result.global_skills.ok) console.log(`Missing global $ skills: ${result.global_skills.missing.join(', ')}. Run: npm i -g sneakoscope, or sks setup from a non-local-only run.`);
@@ -2373,22 +2404,27 @@ async function selftest() {
   await writeTextAtomic(path.join(versionTmp, '.git', 'hooks', 'pre-commit'), '#!/bin/sh\nexit 0\n');
   await initProject(versionTmp, {});
   const versionStatus = await versioningStatus(versionTmp);
-  if (!versionStatus.ok || !versionStatus.enabled || !versionStatus.hook_installed) throw new Error('selftest: versioning hook not installed');
-  const versionHookText = await safeReadText(versionStatus.hook_path);
-  if (!versionHookText.includes('versioning pre-commit')) throw new Error('selftest: versioning hook command missing');
-  if (versionHookText.indexOf('versioning pre-commit') > versionHookText.indexOf('exit 0')) throw new Error('selftest: versioning hook was appended after an early exit');
+  if (!versionStatus.ok || versionStatus.enabled || versionStatus.hook_installed) throw new Error('selftest: versioning hook should stay disabled after init');
+  let versionHookText = await safeReadText(versionStatus.hook_path);
+  if (versionHookText.includes('versioning pre-commit')) throw new Error('selftest: init installed versioning pre-commit');
+  const versionHookAttempt = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'versioning', 'hook', '--json'], { cwd: versionTmp, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
+  if (versionHookAttempt.code === 0 || !versionHookAttempt.stdout.includes('pre_commit_hooks_unsupported')) throw new Error('selftest: versioning hook command should be blocked');
+  const versionBlockedStatus = await versioningStatus(versionTmp);
+  if (versionBlockedStatus.enabled || versionBlockedStatus.hook_installed) throw new Error('selftest: blocked versioning hook changed status');
+  versionHookText = await safeReadText(versionBlockedStatus.hook_path);
+  if (versionHookText.includes('versioning pre-commit')) throw new Error('selftest: blocked versioning hook installed pre-commit command');
   await writeTextAtomic(path.join(versionTmp, 'CHANGELOG.md'), '# Changelog\n\n## [Unreleased]\n\n## [0.1.0] - 2026-05-08\n\n### Fixed\n\n- Initial version selftest fixture.\n');
   await writeTextAtomic(path.join(versionTmp, 'README.md'), 'version selftest\n');
   await runProcess('git', ['add', 'README.md', 'CHANGELOG.md'], { cwd: versionTmp, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
   const preCommitVerify = await runVersionPreCommit(versionTmp);
-  if (!preCommitVerify.ok || preCommitVerify.version !== '0.1.0' || preCommitVerify.changed) throw new Error('selftest: pre-commit should verify current version without bumping');
+  if (!preCommitVerify.ok || !preCommitVerify.skipped || preCommitVerify.reason !== 'disabled_by_policy') throw new Error('selftest: pre-commit path should stay disabled by policy');
   const firstVersionBump = await bumpProjectVersion(versionTmp);
   if (!firstVersionBump.ok || firstVersionBump.version !== '0.1.1' || !firstVersionBump.changed) throw new Error('selftest: first version bump did not advance patch version');
   const bumpedPackage = await readJson(path.join(versionTmp, 'package.json'));
   const bumpedLock = await readJson(path.join(versionTmp, 'package-lock.json'));
   const bumpedChangelog = await safeReadText(path.join(versionTmp, 'CHANGELOG.md'));
   if (bumpedPackage.version !== '0.1.1' || bumpedLock.version !== '0.1.1' || bumpedLock.packages[''].version !== '0.1.1') throw new Error('selftest: package lock versions not synced');
-  if (!bumpedChangelog.includes('## [0.1.1]') || !bumpedChangelog.includes('automatic SKS version guard')) throw new Error('selftest: version bump did not sync changelog section');
+  if (!bumpedChangelog.includes('## [0.1.1]') || !bumpedChangelog.includes('explicit SKS version bump')) throw new Error('selftest: version bump did not sync changelog section');
   const firstCached = await runProcess('git', ['diff', '--cached', '--name-only'], { cwd: versionTmp, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
   if (!firstCached.stdout.includes('package.json') || !firstCached.stdout.includes('package-lock.json') || !firstCached.stdout.includes('CHANGELOG.md')) throw new Error('selftest: version files not staged');
   await runProcess('git', ['commit', '--no-verify', '-m', 'first versioned commit'], { cwd: versionTmp, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
@@ -3305,7 +3341,7 @@ async function selftest() {
   await ensureDir(fakeTmuxDir);
   const fakeTmuxLog = path.join(fakeTmuxDir, 'tmux.log');
   const fakeTmuxBin = path.join(fakeTmuxDir, 'tmux');
-  await writeTextAtomic(fakeTmuxBin, `#!/usr/bin/env node\nconst{appendFileSync:a}=require('node:fs'),e=process.env,c=process.argv[2];if(e.SKS_FAKE_TMUX_LOG)a(e.SKS_FAKE_TMUX_LOG,process.argv.slice(2).join(' ')+'\\n');if(['has-session','kill-session','kill-pane','set-option','select-pane','select-layout','resize-window','set-window-option','set-hook'].includes(c))process.exit(0);if(c==='new-session'){console.log('%1');process.exit(0)}if(c==='split-window'){console.log(e.SKS_FAKE_TMUX_SPLIT_ID||'%2');process.exit(0)}if(c==='list-windows'){console.log('@1');process.exit(0)}if(c==='display-message'){console.log(e.SKS_FAKE_TMUX_DISPLAY||'sks-existing-selftest\\t@1\\t%1');process.exit(0)}if(c==='list-panes'){console.log(e.SKS_FAKE_TMUX_LIST||'');process.exit(0)}process.exit(0);\n`);
+  await writeTextAtomic(fakeTmuxBin, `#!/usr/bin/env node\nconst{appendFileSync:a}=require('fs'),e=process.env,r=process.argv.slice(2),c=r[0];if(e.SKS_FAKE_TMUX_LOG)a(e.SKS_FAKE_TMUX_LOG,r.join(' ')+'\\n');if(c==='new-session')console.log('%1');else if(c==='split-window')console.log(e.SKS_FAKE_TMUX_SPLIT_ID||'%2');else if(c==='list-windows')console.log('@1');else if(c==='display-message')console.log(e.SKS_FAKE_TMUX_DISPLAY||'sks-existing-selftest\\t@1\\t%1');else if(c==='list-sessions')console.log(e.SKS_FAKE_TMUX_SESSIONS||'');else if(c==='list-panes'){let t=r[r.indexOf('-t')+1]||'';console.log(t[0]=='%'&&r.join(' ').includes('pane_dead')?'0\\t'+t:e.SKS_FAKE_TMUX_LIST||'')}\n`);
   await fsp.chmod(fakeTmuxBin, 0o755);
   const previousFakeTmuxLog = process.env.SKS_FAKE_TMUX_LOG;
   const previousPath = process.env.PATH;
@@ -3346,6 +3382,91 @@ async function selftest() {
   const cockpitOpenLog = await safeReadText(fakeTmuxLog);
   if (!cockpitOpen.ok || cockpitOpen.opened_lane_count !== 2 || cockpitOpen.main_pane_id !== '%1' || cockpitOpen.relayout?.layout_name !== 'main-vertical' || !cockpitOpenLog.includes('display-message -p') || !cockpitOpenLog.includes('split-window -h -t %1') || !cockpitOpenLog.includes('set-option -pt %80 @sks_team_managed 1') || !cockpitOpenLog.includes('select-pane -t %1') || !cockpitOpenLog.includes('select-layout -t @1 main-vertical')) throw new Error('selftest: split');
   await writeTextAtomic(fakeTmuxLog, '');
+  process.env.SKS_FAKE_TMUX_SPLIT_ID = '%90';
+  process.env.SKS_FAKE_TMUX_LIST = `%81\tscout: analysis_scout_1\tnode\t1\t${teamId}\tanalysis_scout_1\tscout\n%82\tscout: analysis_scout_1\tnode\t1\t${teamId}\tanalysis_scout_1\tscout\n%84\tscout: analysis_scout_old\tnode\t1\told-team-mission\tanalysis_scout_old\tscout`;
+  const cockpitDedupe = await reconcileTmuxTeamCockpit({
+    root: tmp,
+    missionId: teamId,
+    plan: roleTeamPlan,
+    dashboard: { agents: { analysis_scout_1: { status: 'assigned' } } },
+    control: { status: 'running' },
+    tmux: { bin: fakeTmuxBin },
+    env: { ...process.env, TMUX: '/tmp/tmux-selftest/default,1,0' }
+  });
+  const cockpitDedupeLog = await safeReadText(fakeTmuxLog);
+  if (!cockpitDedupe.ok || cockpitDedupe.closed_lane_count !== 2 || !cockpitDedupeLog.includes('kill-pane -t %82') || !cockpitDedupeLog.includes('kill-pane -t %84') || cockpitDedupeLog.includes('kill-pane -t %81')) throw new Error('selftest: tmux cockpit did not prune duplicate or stale managed panes');
+  await writeTextAtomic(fakeTmuxLog, '');
+  process.env.SKS_FAKE_TMUX_LIST = `%81\tscout: analysis_scout_1\tnode\t1\t${teamId}\tanalysis_scout_1\tscout`;
+  const cockpitTerminal = await reconcileTmuxTeamCockpit({
+    root: tmp,
+    missionId: teamId,
+    plan: roleTeamPlan,
+    dashboard: { agents: { analysis_scout_1: { status: 'completed' } } },
+    control: { status: 'running' },
+    tmux: { bin: fakeTmuxBin },
+    env: { ...process.env, TMUX: '/tmp/tmux-selftest/default,1,0' }
+  });
+  const cockpitTerminalLog = await safeReadText(fakeTmuxLog);
+  if (!cockpitTerminal.ok || cockpitTerminal.closed_lane_count !== 1 || cockpitTerminal.opened_lane_count !== 0 || !cockpitTerminalLog.includes('kill-pane -t %81')) throw new Error('selftest: tmux cockpit did not close terminal agent pane');
+  await writeTextAtomic(fakeTmuxLog, '');
+  const staleTeamId = 'M-20260512-000000-old1';
+  const missionDirOnlyTeamId = 'M-20260512-000000-dir1';
+  await ensureDir(path.join(tmp, '.sneakoscope', 'missions', missionDirOnlyTeamId));
+  await writeJsonAtomic(path.join(tmp, '.sneakoscope', 'state', 'tmux-team-sessions.json'), {
+    schema_version: 1,
+    missions: {
+      [staleTeamId]: {
+        mission_id: staleTeamId,
+        session: `sks-team-${staleTeamId}`,
+        root: tmp,
+        panes: [{ pane_id: '%201', title: 'scout: analysis_scout_1' }]
+      },
+      [teamId]: {
+        mission_id: teamId,
+        session: 'sks-existing-selftest',
+        root: tmp,
+        panes: [{ pane_id: '%204', title: 'scout: analysis_scout_1' }]
+      }
+    }
+  });
+  process.env.SKS_FAKE_TMUX_LIST = [
+    'sks-existing-selftest\t@1\t%1\tCodex CLI\tnode\t\t\t\t',
+    `sks-team-${staleTeamId}\t@70\t%201\tscout: analysis_scout_1\tnode\t\t\t\t`,
+    `sks-existing-selftest\t@1\t%202\treview: stale_review\tnode\t1\t${staleTeamId}\tstale_review\treview`,
+    `sks-team-${missionDirOnlyTeamId}\t@71\t%205\treview: reviewer_1\tnode\t\t\t\t`,
+    'unrelated-session\t@9\t%203\tscout: analysis_scout_1\tnode\t\t\t\t',
+    `sks-existing-selftest\t@1\t%204\tscout: analysis_scout_1\tnode\t1\t${teamId}\tanalysis_scout_1\tscout`
+  ].join('\n');
+  const cockpitSweep = await sweepTmuxTeamSurfaces({
+    root: tmp,
+    keepMissionId: teamId,
+    tmux: { bin: fakeTmuxBin },
+    env: { ...process.env, TMUX: '/tmp/tmux-selftest/default,1,0' }
+  });
+  const cockpitSweepLog = await safeReadText(fakeTmuxLog);
+  if (!cockpitSweep.ok || cockpitSweep.closed_lane_count !== 3 || !cockpitSweepLog.includes('kill-pane -t %201') || !cockpitSweepLog.includes('kill-pane -t %202') || !cockpitSweepLog.includes('kill-pane -t %205') || cockpitSweepLog.includes('kill-pane -t %203') || cockpitSweepLog.includes('kill-pane -t %204') || cockpitSweepLog.includes('kill-pane -t %1')) throw new Error('selftest: tmux sweep did not close only stale recorded Team panes');
+  await writeTextAtomic(fakeTmuxLog, '');
+  const codexLbSuffix = defaultTmuxSessionName(tmp);
+  const codexLbKeepSession = `sks-codex-lb-keep-${codexLbSuffix}`;
+  const codexLbCurrentSession = `sks-codex-lb-current-${codexLbSuffix}`;
+  process.env.SKS_FAKE_TMUX_DISPLAY = `${codexLbCurrentSession}\t@1\t%1`;
+  process.env.SKS_FAKE_TMUX_SESSIONS = [
+    `sks-codex-lb-old-${codexLbSuffix}\t0\t100\t100`,
+    `sks-codex-lb-attached-${codexLbSuffix}\t1\t101\t101`,
+    `${codexLbKeepSession}\t0\t102\t102`,
+    `${codexLbCurrentSession}\t0\t103\t103`,
+    'sks-codex-lb-other-sks-other-00000000\t0\t104\t104'
+  ].join('\n');
+  const codexLbSweep = await sweepCodexLbTmuxSessions({
+    root: tmp,
+    keepSession: codexLbKeepSession,
+    tmux: { bin: fakeTmuxBin },
+    env: { ...process.env, TMUX: '/tmp/tmux-selftest/default,1,0' }
+  });
+  const codexLbSweepLog = await safeReadText(fakeTmuxLog);
+  if (!codexLbSweep.ok || codexLbSweep.closed_session_count !== 1 || !codexLbSweepLog.includes(`kill-session -t sks-codex-lb-old-${codexLbSuffix}`) || codexLbSweepLog.includes(`kill-session -t sks-codex-lb-attached-${codexLbSuffix}`) || codexLbSweepLog.includes(`kill-session -t ${codexLbKeepSession}`) || codexLbSweepLog.includes(`kill-session -t ${codexLbCurrentSession}`) || codexLbSweepLog.includes('kill-session -t sks-codex-lb-other')) throw new Error('selftest: codex-lb tmux sweep did not close only stale detached sessions for this repo');
+  await writeTextAtomic(fakeTmuxLog, '');
+  process.env.SKS_FAKE_TMUX_DISPLAY = 'sks-existing-selftest\t@1\t%1';
   const fakePanes = `%81\tscout: analysis_scout_1\tnode\t1\t${teamId}\tanalysis_scout_1\tscout\n%82\tscout: analysis_scout_2\tnode\t1\t${teamId}\tanalysis_scout_2\tscout\n%83\tuser pane\tzsh\t\t\t\t`;
   process.env.SKS_FAKE_TMUX_LIST = fakePanes;
   const cockpitClose = await reconcileTmuxTeamCockpit({
@@ -3362,6 +3483,7 @@ async function selftest() {
   if (!cockpitClose.ok || cockpitClose.closed_lane_count !== 2 || !cockpitCloseLog.includes('kill-pane -t %81') || !cockpitCloseLog.includes('kill-pane -t %82') || cockpitCloseLog.includes('kill-pane -t %83')) throw new Error('selftest: cleanup');
   delete process.env.SKS_FAKE_TMUX_DISPLAY;
   delete process.env.SKS_FAKE_TMUX_LIST;
+  delete process.env.SKS_FAKE_TMUX_SESSIONS;
   delete process.env.SKS_FAKE_TMUX_SPLIT_ID;
   await writeTextAtomic(fakeTmuxLog, '');
   const madCockpit = await launchMadTmuxUi(['--workspace', 'sks-mad-selftest-ui', '--no-attach'], { root: tmp, tmux: { ok: true, bin: fakeTmuxBin, version: '3.4' }, codex: { bin: process.execPath }, app: { ok: true, guidance: [] }, missionId: 'M-MAD-SELFTEST' });
@@ -3460,9 +3582,26 @@ async function selftest() {
   if (!teamLive.includes('selftest mapped options')) throw new Error('selftest: team live transcript missing event');
   if (!teamLive.includes('Context tracking SSOT: TriWiki')) throw new Error('selftest: team live transcript missing TriWiki context tracking');
   if (!(await readTeamTranscriptTail(teamDir, 1)).join('\n').includes('selftest mapped options')) throw new Error('selftest: team transcript tail missing event');
-  const teamLane = await renderTeamAgentLane(teamDir, { missionId: teamId, agent: 'analysis_scout_1', lines: 4 });
+  const teamLane = await renderTeamAgentLane(teamDir, { missionId: teamId, agent: 'analysis_scout_1', lines: 4, color: false });
   if (!teamLane.includes('selftest mapped repo slice')) throw new Error('selftest: team agent lane missing event context');
-  if (!teamLane.includes('## Codex Chat') || !teamLane.includes('+-- me [status]') || !teamLane.includes('selftest mapped repo slice') || teamLane.includes('## Global Tail')) throw new Error('selftest: chat lane');
+  const missingChatLaneParts = [
+    ['codex chat heading', '## Codex Chat'],
+    ['lane speaker', 'me (analysis_scout_1)'],
+    ['status role metadata', '[status/scout]'],
+    ['agent event body', 'selftest mapped repo slice']
+  ].filter(([, needle]) => !teamLane.includes(needle)).map(([label]) => label);
+  if (missingChatLaneParts.length || teamLane.includes('## Global Tail')) {
+    const reason = [
+      missingChatLaneParts.length ? `missing ${missingChatLaneParts.join(', ')}` : null,
+      teamLane.includes('## Global Tail') ? 'unexpected global tail' : null
+    ].filter(Boolean).join('; ');
+    throw new Error(`selftest: chat lane (${reason})\n${teamLane.slice(0, 1600)}`);
+  }
+  if (!teamLane.includes('╭─') || !teamLane.includes('│ selftest mapped repo slice') || !teamLane.includes('╰─')) {
+    throw new Error(`selftest: team chat lane did not render framed chat blocks\n${teamLane.slice(0, 1600)}`);
+  }
+  const teamLaneColor = await renderTeamAgentLane(teamDir, { missionId: teamId, agent: 'analysis_scout_1', lines: 4, color: true });
+  if (!/\x1b\[[0-9;]+m/.test(teamLaneColor) || !teamLaneColor.includes('Lane color:')) throw new Error('selftest: team chat lane did not render ANSI color metadata/output');
   const teamLaneCli = await runProcess(process.execPath, [hookBin, 'team', 'lane', teamId, '--agent', 'analysis_scout_1', '--lines', '4'], { cwd: tmp, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
   if (teamLaneCli.code !== 0 || !String(teamLaneCli.stdout || '').includes('SKS Team Agent Lane') || !String(teamLaneCli.stdout || '').includes('analysis_scout_1')) throw new Error('selftest: sks team lane CLI did not render an agent lane');
   await writeTextAtomic(path.join(teamDir, 'team-analysis.md'), '- claim: analysis scout mapped route registry | source: src/core/routes.mjs | risk: high | confidence: supported\n');