sneakoscope 0.7.62 → 0.7.64

package/README.md

@@ -239,9 +239,9 @@ sks team log latest
 
 By default, Team missions keep at least five QA/reviewer lanes active. Use explicit role counts only when you need to raise or otherwise pin the lane mix for a specific mission.
 
-Team mode prepares the mission, records live events, compiles runtime tasks and worker inboxes, writes schema-backed effort/work-order/dashboard artifacts, and opens a named tmux Team session with split live lanes by default when tmux is available. Use `--no-open-tmux` for artifact-only mission creation. The default terminal output stays compact: mission id, agent count, role count, tmux status, watch command, and artifact directory. `sks team dashboard` renders the cockpit panes for mission overview, agent lanes, task DAG, QA/dogfood, artifacts/evidence, and performance.
+Team mode prepares the mission, records live events, compiles runtime tasks and worker inboxes, writes schema-backed effort/work-order/dashboard artifacts, and reconciles split live lanes inside the current SKS-owned tmux session when available. Outside an SKS tmux session, `sks team open-tmux --separate-session` keeps the named `sks-team-*` fallback view. Use `--no-open-tmux` for artifact-only mission creation. The default terminal output stays compact: mission id, agent count, role count, tmux status, watch command, and artifact directory. `sks team dashboard` renders the cockpit panes for mission overview, agent lanes, task DAG, QA/dogfood, artifacts/evidence, and performance.
 
-The tmux Team launch is a live orchestration screen in one tmux window: the first pane follows `sks team watch <mission-id> --follow` as the mission overview, and neighboring split panes follow individual `sks team lane <mission-id> --agent <name> --follow` views. Pane headers show only mission, lane, phase, follow command, and cleanup command. SKS sets the Team window to `window-size latest`, installs `client-attached` and `client-resized` hooks, reapplies `resize-window -A`, preserves `window-size latest`, and recalculates the tiled layout so split panes keep fitting when Warp or another terminal is resized. SKS gives lanes role-specific colors, labels, and terminal titles, so scouts, planning/debate voices, executors, reviewers, and safety lanes are visually distinct while detailed evidence is mirrored into `team-transcript.jsonl`, `team-live.md`, and `team-dashboard.json`.
+The tmux Team launch is a live orchestration screen in one tmux window: the main Codex pane stays alive, a managed overview pane follows `sks team watch <mission-id> --follow`, and neighboring managed split panes follow individual `sks team lane <mission-id> --agent <name> --follow` views. Pane headers show only mission, lane, phase, follow command, and cleanup command. SKS tags Team panes with tmux user options, closes only those managed panes when agent lanes complete or cleanup is requested, and recalculates the tiled layout after split/close operations. The separate `sks-team-*` session remains available as a fallback. SKS gives lanes role-specific colors, labels, and terminal titles, so scouts, planning/debate voices, executors, reviewers, and safety lanes are visually distinct while detailed evidence is mirrored into `team-transcript.jsonl`, `team-live.md`, and `team-dashboard.json`.
 
 Team roster and runtime artifacts now include per-agent Fast reasoning metadata. Simple bounded Team lanes can use low reasoning, tool-heavy runtime/CLI/tmux work uses medium, and knowledge, current-docs, safety, DB, release, commit, or research-heavy lanes use high or xhigh as appropriate instead of opening every scout at high.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.62",
+  "version": "0.7.64",
   "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

@@ -307,12 +307,17 @@ export async function ensureGlobalCodexFastModeDuringInstall(opts = {}) {
 export function normalizeCodexFastModeUiConfig(text = '') {
   let next = removeLegacyTopLevelCodexModeLocks(text);
   next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
-  next = removeTomlTableKey(next, 'features', 'hooks');
+  next = removeTomlTableKey(next, 'features', 'codex_hooks');
   next = upsertTopLevelTomlString(next, 'model', 'gpt-5.5');
   next = upsertTopLevelTomlString(next, 'service_tier', 'fast');
-  next = upsertTomlTableKey(next, 'features', 'codex_hooks = true');
+  next = upsertTomlTableKey(next, 'features', 'hooks = true');
+  next = upsertTomlTableKey(next, 'features', 'multi_agent = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode_ui = true');
+  next = upsertTomlTableKey(next, 'features', 'codex_git_commit = true');
+  next = upsertTomlTableKey(next, 'features', 'computer_use = true');
+  next = upsertTomlTableKey(next, 'features', 'apps = true');
+  next = upsertTomlTableKey(next, 'features', 'plugins = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'visible = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'enabled = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
@@ -993,7 +998,7 @@ export async function selftestCodexLb(tmp) {
   if (codexLbNotConfigured.code !== 0 || String(codexLbNotConfigured.stdout || '').includes('codex-lb auth:')) throw new Error('selftest failed: 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 failed: codex-lb status did not advertise repair command');
-  if (!/^model = "gpt-5\.5"/m.test(codexLbConfig) || !codexLbConfig.includes('service_tier = "fast"') || !codexLbConfig.includes('codex_hooks = true') || hasLegacyHooksFeatureFlag(codexLbConfig) || !codexLbConfig.includes('fast_mode = true') || !codexLbConfig.includes('fast_mode_ui = 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 failed: codex-lb setup did not preserve Codex App Fast mode defaults, force GPT-5.5, or migrate the hooks feature flag');
+  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 failed: 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');
   const codexLbLaunch = codexLaunchCommand(tmp, 'codex', []);
   if (!codexLbLaunch.includes('sks-codex-lb.env')) throw new Error('selftest failed: tmux launch command does not source codex-lb env file');
   if (!codexLbLaunch.includes("'--model' 'gpt-5.5'")) throw new Error('selftest failed: tmux launch command without args did not force GPT-5.5');
@@ -1007,7 +1012,7 @@ function hasTopLevelCodexModeLock(text = '') {
   return /(^|\n)\s*model\s*=\s*"codex-lb"\s*(\n|$)/.test(text) || /(^|\n)\s*model_provider\s*=\s*"openai"\s*(\n|$)/.test(text);
 }
 
-function hasLegacyHooksFeatureFlag(text = '') {
+function hasDeprecatedCodexHooksFeatureFlag(text = '') {
   const lines = String(text || '').split('\n');
   const start = lines.findIndex((line) => line.trim() === '[features]');
   if (start === -1) return false;
@@ -1018,5 +1023,5 @@ function hasLegacyHooksFeatureFlag(text = '') {
       break;
     }
   }
-  return lines.slice(start + 1, end).some((line) => /^\s*hooks\s*=/.test(line));
+  return lines.slice(start + 1, end).some((line) => /^\s*codex_hooks\s*=/.test(line));
 }

package/src/cli/main.mjs

@@ -75,7 +75,7 @@ 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, 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, 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, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureRelatedCliTools, ensureSksCommandDuringInstall, ensureTmuxCliTool, globalCodexSkillsRoot, maybePromptCodexLbSetupForLaunch, maybePromptCodexUpdateForLaunch, postinstall, postinstallBootstrapDecision, repairCodexLbAuth, selftestCodexLb, shouldAutoApproveInstall } from './install-helpers.mjs';
@@ -204,9 +204,11 @@ Usage:
   sks goal pause|resume|clear <mission-id|latest>
   sks goal status <mission-id|latest>
   sks team "task" [executor:5 reviewer:6 user:1] [--json]
-  sks team log|tail|watch|lane|status|dashboard [mission-id|latest]
+  sks team log|tail|watch|lane|status|dashboard|open-tmux|attach-tmux [mission-id|latest]
   sks team event [mission-id|latest] --agent <name> --phase <phase> --message "..."
   sks team message [mission-id|latest] --from <agent> --to <agent|all> --message "..."
+  sks team open-tmux [mission-id|latest] [--no-attach|--separate-session]
+  sks team attach-tmux [mission-id|latest]
   sks team cleanup-tmux [mission-id|latest]
   sks research prepare "topic" [--depth frontier]
   sks research run <mission-id|latest> [--mock] [--max-cycles N]
@@ -1452,7 +1454,7 @@ function usage(args = []) {
     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.'],
     tmux: ['tmux', '', '  sks', '  sks tmux open', '  sks tmux check', '  sks tmux status --once', '  sks deps install tmux', '', 'Running bare `sks` opens or reuses the default tmux Codex CLI session in fast-high mode: --model gpt-5.5 -c model_reasoning_effort="high". SKS always forces gpt-5.5; SKS_CODEX_MODEL and SKS_CODEX_FAST_HIGH=0 cannot downgrade or remove that model pin. Use SKS_CODEX_REASONING only for reasoning effort. Before launch, SKS checks npm @openai/codex@latest and prompts Y/n when the installed Codex CLI is missing or outdated. Use `sks tmux open` when you need explicit session/workspace flags, and `sks help` for CLI help.'],
     openclaw: ['OpenClaw', '', '  sks openclaw install', '  sks openclaw path', '  sks openclaw print SKILL.md', '', 'Installs an OpenClaw skill package under ~/.openclaw/skills/sneakoscope-codex so OpenClaw agents can attach skills: [sneakoscope-codex] with the shell tool and call local SKS commands from a project root.'],
-    team: ['Team', '', '  sks team "task" executor:5 reviewer:6 user:1', '  sks team watch latest', '  sks team lane latest --agent analysis_scout_1 --follow', '  sks team message latest --from analysis_scout_1 --to executor_1 --message "handoff note"', '  sks team cleanup-tmux latest', '', '$Team auto-seals a route contract, opens scout-first tmux lanes when available, then runs scouts -> TriWiki attention -> debate -> runtime graph/inbox -> fresh executors -> review -> cleanup -> reflection -> Honest.'],
+    team: ['Team', '', '  sks team "task" executor:5 reviewer:6 user:1', '  sks team open-tmux latest', '  sks team watch latest', '  sks team lane latest --agent analysis_scout_1 --follow', '  sks team message latest --from analysis_scout_1 --to executor_1 --message "handoff note"', '  sks team cleanup-tmux latest', '', '$Team auto-seals a route contract, opens scout-first tmux lanes when available, then runs scouts -> TriWiki attention -> debate -> runtime graph/inbox -> fresh executors -> review -> cleanup -> reflection -> Honest.'],
     'qa-loop': ['QA-LOOP', '', '  sks qa-loop prepare "QA this app"', '  sks qa-loop answer <MISSION_ID> answers.json', '  sks qa-loop run <MISSION_ID> --max-cycles 8', '', 'Report: YYYY-MM-DD-v<version>-qa-report.md'],
     ppt: ['PPT', '', '  $PPT 투자자용 피치덱을 HTML 기반 PDF로 만들어줘', '  $PPT 우리 SaaS 소개자료 만들어줘', '  sks ppt build latest --json', '  sks ppt status latest --json', '', '$PPT infers delivery context, audience profile, STP strategy, decision context, and 3+ pain-point/solution/aha mappings before source research, design-system work, HTML/PDF export, render QA, fact-ledger validation, and bounded review-loop validation. Independent strategy/render/file-write phases run in parallel where inputs allow and are recorded in ppt-parallel-report.json. The visual system must stay simple, restrained, and information-first; editable source HTML is kept under source-html/, PPT-only temporary build files are cleaned, and installed skills/MCPs outside the $PPT allowlist are ignored. Design uses getdesign-reference plus the built-in PPT design pipeline; Codex App $imagegen/gpt-image-2 and Context7 are conditional only when the sealed PPT contract needs raster assets, slide visual critique, or current external docs. Missing required $imagegen/gpt-image-2 output blocks instead of being simulated.'],
     'image-ux-review': ['Image UX Review', '', '  $Image-UX-Review localhost 화면을 이미지 생성 리뷰 루프로 검수해줘', '  $UX-Review 이 스크린샷을 gpt-image-2 콜아웃 리뷰로 분석하고 고쳐줘', '  sks image-ux-review status latest --json', '', '$Image-UX-Review captures or receives source UI screenshots, runs Codex App $imagegen/gpt-image-2 to create generated annotated review images with numbered callouts, then extracts those generated images into image-ux-issue-ledger.json. Text-only screenshot critique cannot pass image-ux-review-gate.json; missing generated review images remain an explicit blocker.'],
@@ -1922,7 +1924,7 @@ function hasTopLevelCodexModeLock(text = '') {
   return (Boolean(model) && model !== 'gpt-5.5') || /^model_reasoning_effort\s*=/m.test(top);
 }
 
-function hasLegacyHooksFeatureFlag(text = '') {
+function hasDeprecatedCodexHooksFeatureFlag(text = '') {
   const lines = String(text || '').split('\n');
   const start = lines.findIndex((line) => line.trim() === '[features]');
   if (start === -1) return false;
@@ -1933,7 +1935,13 @@ function hasLegacyHooksFeatureFlag(text = '') {
       break;
     }
   }
-  return lines.slice(start + 1, end).some((line) => /^\s*hooks\s*=/.test(line));
+  return lines.slice(start + 1, end).some((line) => /^\s*codex_hooks\s*=/.test(line));
+}
+
+const REQUIRED_GENERATED_CODEX_APP_FEATURE_FLAGS = ['hooks', 'multi_agent', 'fast_mode', 'fast_mode_ui', 'codex_git_commit', 'computer_use', 'apps', 'plugins'];
+
+function missingGeneratedCodexAppFeatureFlags(text = '') {
+  return REQUIRED_GENERATED_CODEX_APP_FEATURE_FLAGS.filter((name) => !String(text || '').includes(`${name} = true`));
 }
 
 async function resolveMissionId(root, arg) { return (!arg || arg === 'latest') ? findLatestMission(root) : arg; }
@@ -2150,6 +2158,8 @@ async function selftest() {
   if (await exists(path.join(postinstallSetupTmp, '.agents', 'skills', 'agent-team', 'SKILL.md'))) throw new Error('selftest failed: postinstall installed deprecated agent-team fallback skill');
   if (!String(postinstallSetup.stdout || '').includes('SKS bootstrap: auto-running sks setup --bootstrap --install-scope global --force') || !String(postinstallSetup.stdout || '').includes('SKS Ready')) throw new Error('selftest failed: postinstall did not auto-run global forced bootstrap');
   if (!(await exists(path.join(postinstallSetupTmp, '.codex', 'hooks.json')))) throw new Error('selftest failed: postinstall did not create project hooks during automatic bootstrap');
+  const postinstallSetupConfig = await safeReadText(path.join(postinstallSetupTmp, '.codex', 'config.toml'));
+  if (missingGeneratedCodexAppFeatureFlags(postinstallSetupConfig).length || hasDeprecatedCodexHooksFeatureFlag(postinstallSetupConfig)) throw new Error('selftest failed: postinstall automatic bootstrap did not preserve required Codex App feature flags or migrate deprecated codex_hooks');
   if (!String(postinstallSetup.stdout || '').includes('Codex App global $ skills: installed')) throw new Error('selftest failed: postinstall did not report automatic global Codex App skills');
   if (!String(postinstallSetup.stdout || '').includes('Removed stale generated skill shadow(s):')) throw new Error('selftest failed: postinstall did not report stale first-party plugin shadow cleanup');
   const postinstallSetupManifest = await readJson(path.join(postinstallSetupTmp, '.sneakoscope', 'manifest.json'));
@@ -2184,6 +2194,8 @@ async function selftest() {
   if (postinstallNoMarker.code !== 0) throw new Error(`selftest failed: no-marker postinstall bootstrap exited ${postinstallNoMarker.code}: ${postinstallNoMarker.stderr}`);
   if (!String(postinstallNoMarker.stdout || '').includes('no project marker found; auto-running global SKS runtime bootstrap')) throw new Error('selftest failed: no-marker postinstall did not report global runtime bootstrap');
   if (!(await exists(path.join(postinstallNoMarkerGlobalRoot, '.sneakoscope', 'manifest.json')))) throw new Error('selftest failed: no-marker postinstall did not bootstrap global runtime root');
+  const postinstallNoMarkerConfig = await safeReadText(path.join(postinstallNoMarkerGlobalRoot, '.codex', 'config.toml'));
+  if (missingGeneratedCodexAppFeatureFlags(postinstallNoMarkerConfig).length || hasDeprecatedCodexHooksFeatureFlag(postinstallNoMarkerConfig)) throw new Error('selftest failed: no-marker postinstall bootstrap did not preserve required Codex App feature flags or migrate deprecated codex_hooks');
   if (await exists(path.join(postinstallNoMarkerCwd, '.sneakoscope'))) throw new Error('selftest failed: no-marker postinstall polluted install cwd');
   if (await exists(path.join(postinstallNoMarkerGlobalRoot, '.gitignore'))) throw new Error('selftest failed: global runtime bootstrap without project git wrote shared .gitignore');
   const bootstrapJsonTmp = tmpdir();
@@ -2938,8 +2950,8 @@ async function selftest() {
   if (wikiContext.includes('MANDATORY ambiguity-removal gate activated') || wikiContext.includes('Mission:')) throw new Error('selftest failed: Wiki route created ambiguity mission state');
   if (!wikiJson.systemMessage?.includes('wiki refresh')) throw new Error('selftest failed: Wiki route missing system message');
   const codexConfigText = await safeReadText(path.join(tmp, '.codex', 'config.toml'));
-  if (!codexConfigText.includes('multi_agent = true')) throw new Error('selftest failed: multi_agent not enabled');
-  if (!codexConfigText.includes('codex_hooks = true') || hasLegacyHooksFeatureFlag(codexConfigText)) throw new Error('selftest failed: Codex hooks feature flag not aligned with current codex_hooks setting');
+  const missingCodexConfigFlags = missingGeneratedCodexAppFeatureFlags(codexConfigText);
+  if (missingCodexConfigFlags.length || hasDeprecatedCodexHooksFeatureFlag(codexConfigText)) throw new Error(`selftest failed: generated Codex App feature flags missing or deprecated: ${missingCodexConfigFlags.join(', ')}`);
   if (!hasContext7ConfigText(codexConfigText)) throw new Error('selftest failed: Context7 MCP not configured');
   if (!codexConfigText.includes('[profiles.sks-task-low]') || !codexConfigText.includes('[profiles.sks-task-medium]') || !codexConfigText.includes('[profiles.sks-logic-high]') || !codexConfigText.includes('[profiles.sks-fast-high]') || !codexConfigText.includes('[profiles.sks-research-xhigh]') || !codexConfigText.includes('[profiles.sks-mad-high]')) throw new Error('selftest failed: GPT-5.5 reasoning profiles not configured');
   if (!/\[profiles\.sks-mad-high\][\s\S]*?approval_policy = "never"[\s\S]*?sandbox_mode = "danger-full-access"/.test(codexConfigText)) throw new Error('selftest failed: generated sks-mad-high profile is not full access');
@@ -2947,13 +2959,29 @@ async function selftest() {
   if (!codexConfigText.includes('[agents.team_consensus]')) throw new Error('selftest failed: team_consensus agent not configured');
   const preservedConfigTmp = tmpdir();
   await ensureDir(path.join(preservedConfigTmp, '.codex'));
-  await writeTextAtomic(path.join(preservedConfigTmp, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n\n[notice]\nfast_default_opt_out = true\nkeep = true\n\n[features]\nhooks = true\nfast_mode_ui = true\n\n[user.fast_mode]\nvisible = true\n');
+  await writeTextAtomic(path.join(preservedConfigTmp, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n\n[notice]\nfast_default_opt_out = true\nkeep = true\n\n[features]\ncodex_hooks = true\nfast_mode_ui = false\ncodex_git_commit = false\ncomputer_use = false\napps = false\nplugins = false\ncustom_preview = true\n\n[user.fast_mode]\nvisible = true\n');
   await initProject(preservedConfigTmp, {});
   const preservedConfig = await safeReadText(path.join(preservedConfigTmp, '.codex', 'config.toml'));
   if (!/^model = "gpt-5\.5"/m.test(preservedConfig) || !preservedConfig.includes('service_tier = "fast"') || !preservedConfig.includes('fast_mode = true') || !preservedConfig.includes('fast_mode_ui = true') || !preservedConfig.includes('[user.fast_mode]') || !preservedConfig.includes('visible = true') || !preservedConfig.includes('enabled = true') || !preservedConfig.includes('default_profile = "sks-fast-high"') || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(preservedConfig)) throw new Error('selftest failed: Codex config merge dropped or failed to enable Fast mode defaults and GPT-5.5');
   if (preservedConfig.includes('fast_default_opt_out = true') || !preservedConfig.includes('keep = true')) throw new Error('selftest failed: Codex config merge did not remove stale Fast opt-out notice while preserving other notice keys');
-  if (!preservedConfig.includes('codex_hooks = true') || hasLegacyHooksFeatureFlag(preservedConfig) || !preservedConfig.includes('[profiles.sks-fast-high]')) throw new Error('selftest failed: Codex config merge did not add current SKS hook settings or remove the legacy hooks flag');
+  const missingPreservedFlags = missingGeneratedCodexAppFeatureFlags(preservedConfig);
+  if (missingPreservedFlags.length || hasDeprecatedCodexHooksFeatureFlag(preservedConfig) || !preservedConfig.includes('custom_preview = true') || !preservedConfig.includes('[profiles.sks-fast-high]')) throw new Error(`selftest failed: Codex config merge did not add required app feature flags, preserve existing feature flags, or remove deprecated codex_hooks: ${missingPreservedFlags.join(', ')}`);
   if (hasTopLevelCodexModeLock(preservedConfig)) throw new Error('selftest failed: Codex config merge left top-level legacy model/reasoning locks that hide Fast mode UI');
+  const appFeatureTmp = tmpdir();
+  const fakeCodexApp = path.join(appFeatureTmp, 'Codex.app');
+  const fakeCodexBinDir = path.join(appFeatureTmp, 'bin');
+  await ensureDir(fakeCodexApp);
+  await ensureDir(fakeCodexBinDir);
+  const fakeCodex = path.join(fakeCodexBinDir, 'codex');
+  await writeTextAtomic(fakeCodex, '#!/bin/sh\nif [ "$1" = "mcp" ] && [ "$2" = "list" ]; then printf "%s\\n" "computer-use enabled" "browser-use enabled"; exit 0; fi\nif [ "$1" = "features" ] && [ "$2" = "list" ]; then cat <<EOF\napps                                    stable             true\ncodex_git_commit                        under development  true\ncomputer_use                            stable             true\nfast_mode                               stable             true\nhooks                                   stable             true\nimage_generation                        stable             true\nplugins                                 stable             true\nEOF\nexit 0; fi\necho "unexpected codex $*" >&2\nexit 2\n');
+  await fsp.chmod(fakeCodex, 0o755);
+  const codexAppFeatureStatus = await codexAppIntegrationStatus({ codex: { bin: fakeCodex, version: 'codex-cli 99.0.0' }, home: appFeatureTmp, env: { SKS_CODEX_APP_PATH: fakeCodexApp } });
+  if (!codexAppFeatureStatus.ok || !codexAppFeatureStatus.features?.required_flags_ok || !codexAppFeatureStatus.features?.codex_git_commit) throw new Error('selftest failed: codex-app check did not accept required app feature flags including under-development codex_git_commit');
+  const fakeCodexMissing = path.join(fakeCodexBinDir, 'codex-missing-git-commit');
+  await writeTextAtomic(fakeCodexMissing, '#!/bin/sh\nif [ "$1" = "mcp" ] && [ "$2" = "list" ]; then printf "%s\\n" "computer-use enabled" "browser-use enabled"; exit 0; fi\nif [ "$1" = "features" ] && [ "$2" = "list" ]; then cat <<EOF\napps                                    stable             true\ncodex_git_commit                        under development  false\ncomputer_use                            stable             true\nfast_mode                               stable             true\nhooks                                   stable             true\nimage_generation                        stable             true\nplugins                                 stable             true\nEOF\nexit 0; fi\necho "unexpected codex $*" >&2\nexit 2\n');
+  await fsp.chmod(fakeCodexMissing, 0o755);
+  const codexAppMissingFeatureStatus = await codexAppIntegrationStatus({ codex: { bin: fakeCodexMissing, version: 'codex-cli 99.0.0' }, home: appFeatureTmp, env: { SKS_CODEX_APP_PATH: fakeCodexApp } });
+  if (codexAppMissingFeatureStatus.ok || codexAppMissingFeatureStatus.features?.required_flags_ok || codexAppMissingFeatureStatus.features?.codex_git_commit) throw new Error('selftest failed: codex-app check did not block disabled codex_git_commit feature flag');
   const autoReviewHome = path.join(tmp, 'auto-review-home');
   const autoReviewEnv = { HOME: autoReviewHome };
   const autoReviewEnabled = await enableAutoReview({ env: autoReviewEnv, high: true });
@@ -3169,7 +3197,9 @@ async function selftest() {
   await writeJsonAtomic(path.join(teamDir, 'team-plan.json'), teamPlan);
   if (teamPlan.agent_session_count !== 5) throw new Error('selftest failed: team default sessions not 5');
   if (teamPlan.role_counts.executor !== 3 || teamPlan.role_counts.user !== 1 || teamPlan.role_counts.reviewer !== 5) throw new Error('selftest failed: team default role counts invalid');
-  if (teamPlan.codex_config_required?.features?.codex_hooks !== true || teamPlan.codex_config_required?.features?.hooks === true) throw new Error('selftest failed: team plan Codex config still uses legacy hooks feature flag');
+  const teamPlanFeatureFlags = teamPlan.codex_config_required?.features || {};
+  const missingTeamPlanFeatureFlags = REQUIRED_GENERATED_CODEX_APP_FEATURE_FLAGS.filter((name) => teamPlanFeatureFlags[name] !== true);
+  if (missingTeamPlanFeatureFlags.length || teamPlanFeatureFlags.codex_hooks === true) throw new Error(`selftest failed: team plan Codex config missing required app flags or still uses deprecated codex_hooks: ${missingTeamPlanFeatureFlags.join(', ')}`);
   if (!teamPlan.review_gate?.passed || teamPlan.review_gate.required_reviewer_lanes !== 5) throw new Error('selftest failed: team review policy gate did not pass default plan');
   if (teamPlan.codex_config_required?.service_tier !== 'fast' || teamPlan.reasoning?.service_tier !== 'fast') throw new Error('selftest failed: team plan did not require Fast service tier');
   if (!teamPlan.goal_continuation?.enabled || teamPlan.goal_continuation?.mode !== 'ambient_codex_native_goal_overlay') throw new Error('selftest failed: Team plan did not include ambient Goal continuation');
@@ -3208,6 +3238,7 @@ async function selftest() {
   if (!fromChatTeamPlan.invariants.some((item) => item.includes(FROM_CHAT_IMG_CHECKLIST_ARTIFACT)) || !fromChatTeamPlan.invariants.some((item) => item.includes(FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT)) || !fromChatTeamPlan.invariants.some((item) => item.includes(FROM_CHAT_IMG_QA_LOOP_ARTIFACT))) throw new Error('selftest failed: From-Chat-IMG team plan missing checklist/temp TriWiki/QA invariants');
   const teamWorkflow = teamWorkflowMarkdown(teamPlan);
   if (!teamWorkflow.includes('SSOT: triwiki') || !teamWorkflow.includes('Analysis Scouts') || !teamWorkflow.includes('sks wiki validate')) throw new Error('selftest failed: team workflow missing scout-first TriWiki context tracking');
+  if (!teamWorkflow.includes('sks team open-tmux')) throw new Error('selftest failed: team workflow missing existing-mission tmux open command');
   if (!teamWorkflow.includes(TEAM_GRAPH_ARTIFACT) || !teamWorkflow.includes(TEAM_INBOX_DIR)) throw new Error('selftest failed: team workflow missing runtime graph/inbox guidance');
   if (!teamWorkflow.includes('before every stage') || !teamWorkflow.includes('after findings/artifact changes')) throw new Error('selftest failed: team workflow missing per-stage TriWiki policy');
   const customTeamPlan = buildTeamPlan(teamId, '병렬 구현 팀 테스트', { agentSessions: 5 });
@@ -3241,7 +3272,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 fs = require('node:fs');\nconst log = process.env.SKS_FAKE_TMUX_LOG;\nif (log) fs.appendFileSync(log, process.argv.slice(2).join(' ') + '\\n');\nconst cmd = process.argv[2];\nif (cmd === 'has-session') process.exit(0);\nif (cmd === 'kill-session') process.exit(0);\nif (cmd === 'new-session') { console.log('%1'); process.exit(0); }\nif (cmd === 'split-window') { console.log('%2'); process.exit(0); }\nif (cmd === 'list-windows') { console.log('@1'); process.exit(0); }\nprocess.exit(0);\n`);
+  await writeTextAtomic(fakeTmuxBin, `#!/usr/bin/env node\nconst fs = require('node:fs');\nconst log = process.env.SKS_FAKE_TMUX_LOG;\nif (log) fs.appendFileSync(log, process.argv.slice(2).join(' ') + '\\n');\nconst cmd = process.argv[2];\nif (cmd === 'has-session') process.exit(0);\nif (cmd === 'kill-session') process.exit(0);\nif (cmd === 'kill-pane') process.exit(0);\nif (cmd === 'new-session') { console.log('%1'); process.exit(0); }\nif (cmd === 'split-window') { console.log(process.env.SKS_FAKE_TMUX_SPLIT_ID || '%2'); process.exit(0); }\nif (cmd === 'list-windows') { console.log('@1'); process.exit(0); }\nif (cmd === 'display-message') { console.log(process.env.SKS_FAKE_TMUX_DISPLAY || 'sks-existing-selftest\\t@1\\t%1'); process.exit(0); }\nif (cmd === 'list-panes') { console.log(process.env.SKS_FAKE_TMUX_LIST || ''); process.exit(0); }\nif (cmd === 'set-option' || cmd === 'select-layout' || cmd === 'resize-window' || cmd === 'set-window-option' || cmd === 'set-hook') process.exit(0);\nprocess.exit(0);\n`);
   await fsp.chmod(fakeTmuxBin, 0o755);
   const previousFakeTmuxLog = process.env.SKS_FAKE_TMUX_LOG;
   process.env.SKS_FAKE_TMUX_LOG = fakeTmuxLog;
@@ -3253,6 +3284,48 @@ async function selftest() {
   if (!recreatedTmux.ok || !fakeTmuxLogText.includes('kill-session -t sks-existing-selftest') || !fakeTmuxLogText.includes('new-session') || !fakeTmuxLogText.includes('split-window')) throw new Error('selftest failed: tmux recreate did not replace stale existing session with split panes');
   if (!recreatedTmux.dynamic_resize?.enabled || !fakeTmuxLogText.includes('list-windows -t sks-existing-selftest -F #{window_id}') || !fakeTmuxLogText.includes('set-window-option -t @1 window-size latest') || !fakeTmuxLogText.includes('set-hook -t sks-existing-selftest client-resized') || !fakeTmuxLogText.includes('resize-window -t @1 -A')) throw new Error('selftest failed: tmux dynamic resize hooks were not installed for split panes');
   if (recreatedTmux.layout !== 'tiled' || Number(recreatedTmux.initial_size?.width || 0) < 120 || Number(recreatedTmux.initial_size?.height || 0) < 36) throw new Error('selftest failed: tmux dynamic resize metadata missing normalized initial size/layout');
+  await ensureDir(path.join(tmp, '.sneakoscope', 'state'));
+  await writeJsonAtomic(path.join(tmp, '.sneakoscope', 'state', 'tmux-sessions.json'), {
+    schema_version: 1,
+    sessions: {
+      'sks-existing-selftest': {
+        session: 'sks-existing-selftest',
+        root: tmp,
+        panes: [{ pane_id: '%1', role: 'codex', title: 'Codex CLI' }]
+      }
+    }
+  });
+  await writeTextAtomic(fakeTmuxLog, '');
+  process.env.SKS_FAKE_TMUX_DISPLAY = 'sks-existing-selftest\t@1\t%1';
+  process.env.SKS_FAKE_TMUX_LIST = '';
+  process.env.SKS_FAKE_TMUX_SPLIT_ID = '%80';
+  const cockpitOpen = 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 cockpitOpenLog = await safeReadText(fakeTmuxLog);
+  if (!cockpitOpen.ok || cockpitOpen.opened_lane_count !== 2 || !cockpitOpenLog.includes('display-message -p') || !cockpitOpenLog.includes('split-window -t @1') || !cockpitOpenLog.includes('set-option -pt %80 @sks_team_managed 1') || !cockpitOpenLog.includes('select-layout -t @1 tiled')) throw new Error('selftest failed: dynamic Team cockpit did not split managed panes in the current SKS tmux session');
+  await writeTextAtomic(fakeTmuxLog, '');
+  process.env.SKS_FAKE_TMUX_LIST = `%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`;
+  const cockpitClose = await reconcileTmuxTeamCockpit({
+    root: tmp,
+    missionId: teamId,
+    plan: roleTeamPlan,
+    dashboard: { agents: { analysis_scout_1: { status: 'completed' }, analysis_scout_2: { status: 'assigned' } } },
+    control: { status: 'running' },
+    tmux: { bin: fakeTmuxBin },
+    env: { ...process.env, TMUX: '/tmp/tmux-selftest/default,1,0' }
+  });
+  const cockpitCloseLog = await safeReadText(fakeTmuxLog);
+  if (!cockpitClose.ok || cockpitClose.closed_lane_count !== 1 || !cockpitCloseLog.includes('kill-pane -t %81') || cockpitCloseLog.includes('kill-pane -t %83')) throw new Error('selftest failed: dynamic Team cockpit did not close only stale managed panes');
+  delete process.env.SKS_FAKE_TMUX_DISPLAY;
+  delete process.env.SKS_FAKE_TMUX_LIST;
+  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' });
   const madTmuxLogText = await safeReadText(fakeTmuxLog);
@@ -3344,6 +3417,7 @@ async function selftest() {
   if (!teamDashboard?.latest_messages?.some((entry) => entry.agent === 'team_consensus')) throw new Error('selftest failed: team live dashboard missing agent event');
   const teamLive = await readTeamLive(teamDir);
   if (!teamLive.includes('Analysis scouts') || !teamLive.includes('selftest mapped repo slice')) throw new Error('selftest failed: team live transcript missing analysis scout section/event');
+  if (!teamLive.includes('sks team open-tmux')) throw new Error('selftest failed: team live transcript missing existing-mission tmux open command');
   if (!teamLive.includes('selftest mapped options')) throw new Error('selftest failed: team live transcript missing event');
   if (!teamLive.includes('Context tracking SSOT: TriWiki')) throw new Error('selftest failed: team live transcript missing TriWiki context tracking');
   if (!(await readTeamTranscriptTail(teamDir, 1)).join('\n').includes('selftest mapped options')) throw new Error('selftest failed: team transcript tail missing event');

package/src/cli/maintenance-commands.mjs

@@ -30,7 +30,7 @@ import { PIPELINE_PLAN_ARTIFACT, validatePipelinePlan, writePipelinePlan } from
 import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../core/goal-workflow.mjs';
 import { scanCodeStructure, writeCodeStructureReport } from '../core/code-structure.mjs';
 import { writeMemorySweepReport } from '../core/memory-governor.mjs';
-import { cleanupTmuxTeamView, defaultTmuxSessionName, launchMadTmuxUi, launchTmuxTeamView, sanitizeTmuxSessionName } from '../core/tmux-ui.mjs';
+import { cleanupTmuxTeamView, defaultTmuxSessionName, launchMadTmuxUi, launchTmuxTeamView, reconcileTmuxTeamCockpit, sanitizeTmuxSessionName } from '../core/tmux-ui.mjs';
 import { loadSkillDreamState, recordSkillDreamEvent, runSkillDream, writeSkillForgeReport } from '../core/skill-forge.mjs';
 import { writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
 import { checkDbOperation, checkSqlFile, classifyCommand, classifySql, loadDbSafetyPolicy, safeSupabaseMcpConfig, scanDbSafety } from '../core/db-safety.mjs';
@@ -516,7 +516,7 @@ async function goalCreate(args) {
   if (!prompt) throw new Error('Missing goal task prompt.');
   const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
   const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
-  await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: 'GOAL_READY', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'none' });
+  await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: 'GOAL_READY', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'none' }, { replace: true });
   console.log(`Goal mission created: ${id}`);
   console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
   console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);
@@ -529,7 +529,7 @@ async function goalControl(action, args) {
   if (!id) throw new Error(`Usage: sks goal ${action} <mission-id|latest>`);
   const { dir } = await loadMission(root, id);
   const workflow = await updateGoalWorkflow(dir, action);
-  await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: `GOAL_${String(action).toUpperCase()}`, native_goal: workflow.native_goal, questions_allowed: true, implementation_allowed: action !== 'pause' && action !== 'clear', stop_gate: 'none' });
+  await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: `GOAL_${String(action).toUpperCase()}`, native_goal: workflow.native_goal, questions_allowed: true, implementation_allowed: action !== 'pause' && action !== 'clear', stop_gate: 'none' }, { replace: true });
   console.log(`Goal ${action}: ${id}`);
   console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
 }
@@ -1626,7 +1626,7 @@ export async function gxCommand(sub, args) {
 }
 
 export async function team(args) {
-  const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'message', 'cleanup-tmux']);
+  const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'message', 'open-tmux', 'attach-tmux', 'cleanup-tmux']);
   if (teamSubcommands.has(args[0])) return teamCommand(args[0], args.slice(1));
   const jsonOutput = flag(args, '--json');
   const openTmux = !jsonOutput && !flag(args, '--no-open-tmux') && !flag(args, '--no-tmux');
@@ -1635,7 +1635,7 @@ export async function team(args) {
   const { prompt, agentSessions, roleCounts, roster } = opts;
   if (!prompt) {
     console.error('Usage: sks team "task" [executor:5 reviewer:6 user:1] [--agents N] [--no-open-tmux] [--json]');
-    console.error('       sks team log|tail|watch|lane|status|message|cleanup-tmux [mission-id|latest]');
+    console.error('       sks team log|tail|watch|lane|status|message|open-tmux|attach-tmux|cleanup-tmux [mission-id|latest]');
     console.error('       sks team event [mission-id|latest] --agent <name> --phase <phase> --message "..."');
     console.error('       sks team message [mission-id|latest] --from <agent> --to <agent|all> --message "..."');
     process.exitCode = 1;
@@ -1778,7 +1778,7 @@ export function buildTeamPlan(id, prompt, opts = {}) {
     reasoning: teamReasoningPolicy(prompt, roster),
     codex_config_required: {
       service_tier: 'fast',
-      features: { multi_agent: true, codex_hooks: true },
+      features: { multi_agent: true, hooks: true, fast_mode: true, fast_mode_ui: true, codex_git_commit: true, computer_use: true, apps: true, plugins: true },
       agents: { max_threads: 6, max_depth: 1 },
       custom_agents_dir: '.codex/agents'
     },
@@ -1887,6 +1887,7 @@ export function buildTeamPlan(id, prompt, opts = {}) {
         'sks team status <mission-id>',
         'sks team log <mission-id>',
         'sks team tail <mission-id>',
+        'sks team open-tmux <mission-id>',
         'sks team watch <mission-id>',
         'sks team lane <mission-id> --agent <name> --follow',
         'sks team event <mission-id> --agent <name> --phase <phase> --message "..."',
@@ -1967,7 +1968,7 @@ ${plan.roster.validation_team.map((agent) => `- ${agent.id}: ${agent.persona} [r
 - Keep team-live.md readable for the user inside Codex App.
 - Mirror every useful subagent status, debate result, handoff, review finding, and integration decision to team-transcript.jsonl.
 - Use \`sks team event ${plan.mission_id} --agent <name> --phase <phase> --message "..."\` when recording a live event from the parent thread.
-- The user can inspect the flow with \`sks team log ${plan.mission_id}\`, \`sks team tail ${plan.mission_id}\`, \`sks team watch ${plan.mission_id}\`, or \`sks team lane ${plan.mission_id} --agent analysis_scout_1 --follow\`.
+- The user can inspect the flow with \`sks team open-tmux ${plan.mission_id}\`, \`sks team log ${plan.mission_id}\`, \`sks team tail ${plan.mission_id}\`, \`sks team watch ${plan.mission_id}\`, or \`sks team lane ${plan.mission_id} --agent analysis_scout_1 --follow\`.
 
 ## Phases
 
@@ -1989,6 +1990,37 @@ async function teamCommand(sub, args) {
     return;
   }
   const { dir } = await loadMission(root, id);
+  if (sub === 'open-tmux' || sub === 'attach-tmux') {
+    const plan = await readJson(path.join(dir, 'team-plan.json'), null);
+    if (!plan) {
+      console.error(`Team plan missing for ${id}; cannot open tmux Team view.`);
+      process.exitCode = 2;
+      return;
+    }
+    const tmux = await launchTmuxTeamView({
+      root,
+      missionId: id,
+      plan,
+      promptFile: path.join(dir, 'team-workflow.md'),
+      json: flag(args, '--json'),
+      attach: sub === 'attach-tmux' || !flag(args, '--no-attach'),
+      args
+    });
+    if (flag(args, '--json')) return console.log(JSON.stringify(tmux, null, 2));
+    if (!tmux.ready) {
+      const reasons = [tmux.opened?.stderr, ...(tmux.blockers || [])].filter(Boolean);
+      console.error(`tmux Team view blocked for ${id}: ${reasons.join('; ') || 'tmux creation failed'}`);
+      if (tmux.attach_command) console.error(`Attach after repair: ${tmux.attach_command}`);
+      process.exitCode = 2;
+      return;
+    }
+    console.log(`tmux: opened ${tmux.opened_lane_count || tmux.lanes?.length || 0} Team lane(s) in ${tmux.session}`);
+    if (tmux.split_ui?.mode) console.log(`tmux UI: ${tmux.split_ui.mode} (${tmux.split_ui.layout})`);
+    if (tmux.split_ui?.current_session) console.log('tmux cockpit: reconciled inside the current SKS tmux window');
+    console.log(`Attach: ${tmux.attach_command}`);
+    console.log(`Watch: sks team watch ${id}`);
+    return;
+  }
   if (sub === 'event') {
     const message = readFlagValue(args, '--message', '');
     if (!message) {
@@ -1997,6 +2029,7 @@ async function teamCommand(sub, args) {
       return;
     }
     const phase = readFlagValue(args, '--phase', 'general');
+    const plan = await readJson(path.join(dir, 'team-plan.json'), null).catch(() => null);
     const record = await appendTeamEvent(dir, {
       agent: readFlagValue(args, '--agent', 'parent_orchestrator'),
       phase,
@@ -2004,16 +2037,29 @@ async function teamCommand(sub, args) {
       artifact: readFlagValue(args, '--artifact', ''),
       message
     });
+    const cockpit = plan
+      ? await reconcileTmuxTeamCockpit({
+        root,
+        missionId: id,
+        plan,
+        promptFile: path.join(dir, 'team-workflow.md'),
+        close: /^session_cleanup$|^team_cleanup$|^cleanup$/i.test(String(phase || '')),
+        plannedFallback: false
+      }).catch((err) => ({ ok: false, skipped: true, reason: err.message || 'tmux cockpit reconcile failed' }))
+      : null;
     const tmuxCleanup = /^session_cleanup$|^team_cleanup$|^cleanup$/i.test(String(phase || ''))
       ? await requestTeamSessionCleanup(dir, {
         missionId: id,
         agent: readFlagValue(args, '--agent', 'parent_orchestrator'),
         reason: message,
-        finalMessage: 'Team cleanup event received. Follow panes may stop; tmux panes remain user-controlled.'
+        finalMessage: 'Team cleanup event received. Managed tmux Team panes may close; follow loops may stop.'
       }).then(() => cleanupTmuxTeamView({ root, missionId: id, closeSession: flag(args, '--close-session') || flag(args, '--close') })).catch((err) => ({ ok: false, reason: err.message || 'tmux cleanup failed' }))
       : null;
     if (flag(args, '--json')) return console.log(JSON.stringify(record, null, 2));
     console.log(`${record.ts} [${record.phase}] ${record.agent}: ${record.message}`);
+    if (cockpit?.ok && (cockpit.opened_lane_count || cockpit.closed_lane_count)) {
+      console.log(`tmux cockpit: +${cockpit.opened_lane_count || 0} -${cockpit.closed_lane_count || 0} managed pane(s) in ${cockpit.session}`);
+    }
     if (tmuxCleanup) {
       if (tmuxCleanup.ok) console.log(`tmux cleanup: marked complete (${tmuxCleanup.reason || 'record updated'})`);
       else console.log(`tmux cleanup: skipped (${tmuxCleanup.reason || 'not available'})`);
@@ -2045,7 +2091,7 @@ async function teamCommand(sub, args) {
       missionId: id,
       agent: readFlagValue(args, '--agent', 'parent_orchestrator'),
       reason: readFlagValue(args, '--reason', 'Team session ended; clean up live follow panes.'),
-      finalMessage: 'Team session ended. Lane/watch follow loops will stop after showing this cleanup summary; tmux panes remain user-controlled.'
+      finalMessage: 'Team session ended. Lane/watch follow loops will stop after showing this cleanup summary; managed tmux Team panes may close.'
     });
     await appendTeamEvent(dir, {
       agent: readFlagValue(args, '--agent', 'parent_orchestrator'),

package/src/core/codex-app.mjs

@@ -7,6 +7,7 @@ import { getCodexInfo } from './codex-adapter.mjs';
 export const CODEX_APP_DOCS_URL = 'https://developers.openai.com/codex/app/features';
 export const CODEX_CHANGELOG_URL = 'https://developers.openai.com/codex/changelog';
 export const CODEX_REMOTE_CONTROL_MIN_VERSION = '0.130.0';
+const REQUIRED_CODEX_APP_FEATURE_FLAGS = ['codex_git_commit', 'hooks', 'fast_mode', 'computer_use', 'apps', 'plugins'];
 
 export function codexAppCandidatePaths(home = os.homedir(), env = process.env) {
   const candidates = [];
@@ -106,10 +107,12 @@ export async function codexAppIntegrationStatus(opts = {}) {
   const computerUseMcpListed = /computer[-_ ]?use/i.test(mcpText);
   const browserUseMcpListed = /browser[-_ ]?use/i.test(mcpText);
   const imageGenerationReady = codexFeatureEnabled(featureText, 'image_generation');
+  const requiredFeatureFlags = Object.fromEntries(REQUIRED_CODEX_APP_FEATURE_FLAGS.map((name) => [name, codexFeatureEnabled(featureText, name)]));
+  const requiredFeatureFlagsOk = Object.values(requiredFeatureFlags).every(Boolean);
   const computerUseReady = computerUseMcpListed || Boolean(computerUsePath);
   const browserUseReady = browserUseMcpListed || Boolean(browserUsePath);
   const appInstalled = Boolean(appPath);
-  const ready = appInstalled && Boolean(codex.bin) && mcpList.ok && featureList.ok && imageGenerationReady && computerUseReady && browserUseReady;
+  const ready = appInstalled && Boolean(codex.bin) && mcpList.ok && featureList.ok && requiredFeatureFlagsOk && imageGenerationReady && computerUseReady && browserUseReady;
   return {
     ok: ready,
     app: {
@@ -136,6 +139,9 @@ export async function codexAppIntegrationStatus(opts = {}) {
     features: {
       checked: featureList.checked,
       ok: featureList.ok,
+      ...requiredFeatureFlags,
+      required_flags: requiredFeatureFlags,
+      required_flags_ok: requiredFeatureFlagsOk,
       image_generation: imageGenerationReady,
       image_generation_source: imageGenerationReady ? 'codex_features_list' : 'missing',
       stdout: featureList.stdout,
@@ -145,7 +151,7 @@ export async function codexAppIntegrationStatus(opts = {}) {
       computer_use_cache: computerUsePath,
       browser_use_cache: browserUsePath
     },
-    guidance: codexAppGuidance({ appInstalled, codex, mcpList, featureList, imageGenerationReady, computerUseReady, browserUseReady, computerUseMcpListed, browserUseMcpListed, remoteControl })
+    guidance: codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags, requiredFeatureFlagsOk, imageGenerationReady, computerUseReady, browserUseReady, computerUseMcpListed, browserUseMcpListed, remoteControl })
   };
 }
 
@@ -200,7 +206,7 @@ export function formatCodexRemoteControlStatus(status) {
   return lines.filter(Boolean).join('\n');
 }
 
-export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, imageGenerationReady, computerUseReady, browserUseReady, computerUseMcpListed, browserUseMcpListed, remoteControl }) {
+export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags = {}, requiredFeatureFlagsOk = true, imageGenerationReady, computerUseReady, browserUseReady, computerUseMcpListed, browserUseMcpListed, remoteControl }) {
   const lines = [];
   if (!appInstalled) {
     lines.push('Install and open Codex App for first-party MCP/plugin tools. SKS tmux launch can still run with Codex CLI alone, but Codex Computer Use and imagegen/gpt-image-2 evidence will be unavailable until Codex App is ready.');
@@ -221,6 +227,11 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, im
     lines.push(`Codex feature check failed: ${summarizeCodexMcpError(featureList.stderr || featureList.stdout)}`);
     lines.push('Verify with: codex features list');
   }
+  if (featureList?.checked && featureList.ok && !requiredFeatureFlagsOk) {
+    const missing = missingRequiredFeatureFlags(requiredFeatureFlags);
+    lines.push(`Codex App feature flag(s) disabled or missing: ${missing.join(', ')}. Commit message generation and app-only tool paths can fail even when CLI chat works.`);
+    lines.push('Verify with: codex features list | rg "codex_git_commit|hooks|fast_mode|computer_use|apps|plugins"');
+  }
   if (appInstalled && (!computerUseReady || !browserUseReady)) {
     lines.push('Open Codex App settings and enable recommended MCP/plugin tools. Codex CLI 0.130.0+ remote-control/app-server sessions can pick up config changes live; restart older CLI/TUI sessions.');
     lines.push('Required for SKS QA-LOOP UI/browser evidence: Codex Computer Use only. Browser Use can support non-UI browser context, but it does not satisfy UI-level E2E verification.');
@@ -232,7 +243,7 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, im
     lines.push('Codex image_generation was not visible from `codex features list`. Required imagegen/gpt-image-2 evidence must stay blocked or unverified until $imagegen is available in Codex App.');
   }
   if (computerUseReady && !computerUseMcpListed) {
-    lines.push('Computer Use plugin files are installed, but this check cannot prove the current thread exposes the live Computer Use tools. Start a new Codex App thread and invoke @Computer or @AppName; if the tool is still absent from the model tool list, mark UI/browser evidence unverified.');
+    lines.push('Computer Use plugin files are installed, but this check cannot prove the current thread exposes the live Computer Use tools. Start a new Codex App thread and invoke @Computer or @AppName for the actual target app or screen; Codex App readiness itself should stay on `codex features list`, `codex mcp list`, and `sks codex-app check`.');
   }
   if (browserUseReady && !browserUseMcpListed) {
     lines.push('Browser Use plugin files are installed, but `codex mcp list` does not list a browser-use MCP server. Treat Browser Use as plugin-scoped, not as SKS UI verification evidence.');
@@ -248,6 +259,7 @@ export function formatCodexAppStatus(status, { includeRaw = false } = {}) {
     `Codex App:   ${status.app.installed ? 'ok' : 'missing'}${status.app.path ? ` ${status.app.path}` : ''}`,
     `Codex CLI:   ${status.codex_cli.ok ? 'ok' : 'missing'}${status.codex_cli.version ? ` ${status.codex_cli.version}` : ''}`,
     `Remote Ctrl: ${status.remote_control?.ok ? 'ok' : 'missing'}${status.remote_control?.codex_cli?.version_number ? ` min ${status.remote_control.min_version}` : ''}`,
+    `App Flags:  ${status.features?.required_flags_ok ? 'ok' : `missing ${missingRequiredFeatureFlags(status.features?.required_flags).join(', ') || 'required flags'}`}`,
     `Computer Use:${status.mcp.has_computer_use ? status.mcp.computer_use_source === 'plugin_cache' ? ' installed (verify @Computer in thread)' : ' ok' : ' missing'}`,
     `Browser Use: ${status.mcp.has_browser_use ? status.mcp.browser_use_source === 'plugin_cache' ? 'installed (plugin scoped)' : 'ok' : 'missing'}`,
     `Image Gen:   ${status.features?.image_generation ? 'ok ($imagegen/gpt-image-2)' : status.features?.checked ? 'missing' : 'not checked'}`,
@@ -273,12 +285,15 @@ function summarizeCodexMcpError(text) {
 }
 
 function codexFeatureEnabled(text, featureName) {
-  const name = escapeRegExp(featureName);
-  return new RegExp(`(?:^|\\n)\\s*${name}\\s+\\S+\\s+true\\b`, 'i').test(String(text || ''));
+  const expected = String(featureName || '').toLowerCase();
+  return String(text || '').split(/\r?\n/).some((line) => {
+    const parts = line.trim().split(/\s+/).filter(Boolean);
+    return parts[0]?.toLowerCase() === expected && parts[parts.length - 1]?.toLowerCase() === 'true';
+  });
 }
 
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function missingRequiredFeatureFlags(flags = {}) {
+  return REQUIRED_CODEX_APP_FEATURE_FLAGS.filter((name) => flags?.[name] !== true);
 }
 
 function remoteControlGuidance(status = {}) {

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.7.62';
+export const PACKAGE_VERSION = '0.7.64';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/hooks-runtime.mjs

@@ -744,6 +744,7 @@ async function teamLiveDigest(root, state = {}) {
   const lines = events.map(formatTeamDigestEvent);
   const context = boundText([
     `SKS Team live digest: mission ${id}, phase ${phase}, source ${source}.`,
+    `Open tmux multi-view with: sks team open-tmux ${id}`,
     `Open live view with: sks team watch ${id}`,
     'Recent events:',
     ...lines.map((line) => `- ${line}`)

package/src/core/init.mjs

@@ -440,13 +440,17 @@ function installPolicy(scope, commandPrefix) {
 function mergeManagedCodexConfigToml(existingContent = '') {
   let next = removeLegacyTopLevelCodexModeLocks(String(existingContent || '').trimEnd());
   next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
-  next = removeTomlTableKey(next, 'features', 'hooks');
+  next = removeTomlTableKey(next, 'features', 'codex_hooks');
   next = upsertTopLevelTomlString(next, 'model', 'gpt-5.5');
   next = upsertTopLevelTomlString(next, 'service_tier', 'fast');
-  next = upsertTomlTableKey(next, 'features', 'codex_hooks = true');
+  next = upsertTomlTableKey(next, 'features', 'hooks = true');
   next = upsertTomlTableKey(next, 'features', 'multi_agent = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode_ui = true');
+  next = upsertTomlTableKey(next, 'features', 'codex_git_commit = true');
+  next = upsertTomlTableKey(next, 'features', 'computer_use = true');
+  next = upsertTomlTableKey(next, 'features', 'apps = true');
+  next = upsertTomlTableKey(next, 'features', 'plugins = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'visible = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'enabled = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
@@ -733,7 +737,7 @@ function codexAppQuickReference(scope, commandPrefix) {
     `Context Tracking: TriWiki SSOT. Before each route phase read only the latest coordinate+voxel overlay pack at .sneakoscope/wiki/context-pack.json; coordinate-only legacy packs are invalid. Use attention.use_first for compact high-trust recall and hydrate attention.hydrate_first from source before risky/lower-trust decisions. During every stage hydrate low-trust claims from source/hash/RGBA anchors; after changes run ${commandPrefix} wiki refresh or pack; before handoff/final run ${commandPrefix} wiki validate .sneakoscope/wiki/context-pack.json.`,
     stackCurrentDocsPolicyText(commandPrefix),
     `Team review: ${MIN_TEAM_REVIEW_POLICY_TEXT}`,
-    `Team tmux view: ${commandPrefix} team "task" prepares live watch/lane commands and opens a named Team tmux multi-pane view by default when tmux is available; add --no-open-tmux for artifact-only creation. The view has an overview watch pane plus color-coded split per-agent lanes; ${commandPrefix} team lane latest --agent analysis_scout_1 --follow shows one agent's status, assigned runtime tasks, recent agent events, direct messages, and fallback global tail; ${commandPrefix} team message latest --from analysis_scout_1 --to executor_1 --message "handoff note" mirrors bounded agent communication into transcript/lane panes; ${commandPrefix} team cleanup-tmux latest marks the SKS session record complete and asks follow panes to show a cleanup summary then stop.`,
+    `Team tmux view: ${commandPrefix} team "task" prepares live watch/lane commands and reconciles managed Team panes inside the current SKS-owned tmux session when available; add --no-open-tmux for artifact-only creation or --separate-session to force the named sks-team-* fallback. Existing hook-created Team missions can be opened later with ${commandPrefix} team open-tmux latest. The view keeps the main Codex pane alive, adds an overview watch pane plus color-coded split per-agent lanes, and closes only SKS-managed Team panes as agent lanes finish or cleanup is requested; ${commandPrefix} team lane latest --agent analysis_scout_1 --follow shows one agent's status, assigned runtime tasks, recent agent events, direct messages, and fallback global tail; ${commandPrefix} team message latest --from analysis_scout_1 --to executor_1 --message "handoff note" mirrors bounded agent communication into transcript/lane panes; ${commandPrefix} team cleanup-tmux latest marks the SKS session record complete and asks managed panes/follow loops to close or show a cleanup summary.`,
     `Runtime: open Codex App once, then run ${commandPrefix} bootstrap and ${commandPrefix} deps check. Bare ${commandPrefix} opens or reuses the default tmux/Codex CLI session; before launch it checks npm @openai/codex@latest and prompts Y/n when the installed Codex CLI is missing or outdated. ${commandPrefix} codex-app remote-control wraps the Codex CLI 0.130.0+ headless remote-control entrypoint. ${commandPrefix} tmux open is the explicit form for session/workspace flags.`,
     `Guard: generated harness files are immutable outside the engine source repo; check ${commandPrefix} guard check; conflicts use ${commandPrefix} conflicts prompt with human approval.`
   ].join('\n') + '\n';

package/src/core/mission.mjs

@@ -62,7 +62,7 @@ export async function findLatestMission(root) {
   return candidates.at(-1)?.id || null;
 }
 
-export async function setCurrent(root, patch) {
-  const current = await readJson(stateFile(root), {});
+export async function setCurrent(root, patch, opts = {}) {
+  const current = opts.replace ? {} : await readJson(stateFile(root), {});
   await writeJsonAtomic(stateFile(root), { ...current, ...patch, updated_at: nowIso() });
 }

package/src/core/pipeline.mjs

@@ -803,7 +803,7 @@ async function materializeAutoSealedTeam(root, id, dir, route, task, contractHas
       transcript: 'team-transcript.jsonl',
       dashboard: 'team-dashboard.json',
       tmux: 'CLI Team entrypoints open tmux live lanes for the visible Team agent budget when tmux is available.',
-      commands: ['sks team status latest', 'sks team log latest', 'sks team tail latest', 'sks team watch latest', 'sks team lane latest --agent <name> --follow']
+      commands: ['sks team status latest', 'sks team log latest', 'sks team tail latest', 'sks team open-tmux latest', 'sks team watch latest', 'sks team lane latest --agent <name> --follow']
     },
     required_artifacts: ['team-roster.json', 'team-analysis.md', ...(fromChatImgRequired ? [FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT] : []), 'team-consensus.md', ...teamRuntimeRequiredArtifacts(), 'team-review.md', 'team-gate.json', TEAM_SESSION_CLEANUP_ARTIFACT, 'reflection.md', 'reflection-gate.json', 'team-live.md', 'team-transcript.jsonl', 'team-dashboard.json', '.sneakoscope/wiki/context-pack.json', 'context7-evidence.jsonl']
   };
@@ -894,7 +894,7 @@ async function prepareTeam(root, route, task, required, opts = {}) {
       transcript: 'team-transcript.jsonl',
       dashboard: 'team-dashboard.json',
       tmux: 'CLI Team entrypoints open tmux live lanes for the visible Team agent budget when tmux is available.',
-      commands: ['sks team status latest', 'sks team log latest', 'sks team tail latest', 'sks team watch latest', 'sks team lane latest --agent <name> --follow', 'sks team event latest --agent <name> --phase <phase> --message "..."']
+      commands: ['sks team status latest', 'sks team log latest', 'sks team tail latest', 'sks team open-tmux latest', 'sks team watch latest', 'sks team lane latest --agent <name> --follow', 'sks team event latest --agent <name> --phase <phase> --message "..."']
     },
     required_artifacts: ['team-roster.json', 'team-analysis.md', ...(fromChatImgRequired ? [FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT] : []), 'team-consensus.md', ...teamRuntimeRequiredArtifacts(), 'team-review.md', 'team-gate.json', TEAM_SESSION_CLEANUP_ARTIFACT, 'reflection.md', 'reflection-gate.json', 'team-live.md', 'team-transcript.jsonl', 'team-dashboard.json', '.sneakoscope/wiki/context-pack.json', 'context7-evidence.jsonl']
   };

package/src/core/routes.mjs

@@ -33,7 +33,7 @@ export const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = 'codex_computer_use';
 export const CODEX_IMAGEGEN_EVIDENCE_SOURCE = 'codex_app_imagegen_gpt_image_2';
 export const CODEX_APP_IMAGE_GENERATION_DOC_URL = 'https://developers.openai.com/codex/app/features#image-generation';
 export const OPENAI_IMAGE_GENERATION_DOC_URL = 'https://developers.openai.com/api/docs/guides/image-generation';
-export const CODEX_COMPUTER_USE_ONLY_POLICY = 'Pipeline UI/browser verification and visual inspection must use Codex Computer Use only. Do not use or install Playwright packages, Chrome MCP, Browser Use, Selenium, Puppeteer, or any other browser automation substitute; if Codex Computer Use is unavailable, mark the UI/browser evidence unverified instead of substituting another tool. In Codex App prompts, invoke @Computer or @AppName in a new thread when live Computer Use tools are needed; SKS hooks and skills can require the policy but cannot attach missing host tools to an already-started turn.';
+export const CODEX_COMPUTER_USE_ONLY_POLICY = 'Pipeline UI/browser verification and visual inspection must use Codex Computer Use only. Do not use or install Playwright packages, Chrome MCP, Browser Use, Selenium, Puppeteer, or any other browser automation substitute; if Codex Computer Use is unavailable for the target UI, mark the UI/browser evidence unverified instead of substituting another tool. Codex App readiness/config verification is not target-UI evidence: use the Codex-provided control surfaces `codex features list`, `codex mcp list`, `sks codex-app check`, remote-control status, and plugin/tool exposure, not direct OS Accessibility control of the Codex App bundle. In Codex App prompts, invoke @Computer or @AppName in a new thread when live Computer Use tools are needed for the actual target app or screen; SKS hooks and skills can require the policy but cannot attach missing host tools to an already-started turn.';
 export const CODEX_IMAGEGEN_REQUIRED_POLICY = 'Pipeline image generation, raster asset creation/editing, and generated image-review evidence must use real Codex App imagegen/$imagegen with gpt-image-2 when that evidence is required. Do not substitute placeholder SVG/HTML/CSS, prose-only critique, stock-like stand-ins, manually fabricated files, or missing-output ledgers for requested/generated raster assets or required generated review images. If imagegen/gpt-image-2 is unavailable, record the blocker and mark the image asset or review evidence unverified instead of passing the gate. In Codex App prompts, invoke $imagegen when live image generation is needed; SKS hooks and skills can require the policy but cannot attach missing host image-generation tools to an already-started turn.';
 export const RESERVED_CODEX_PLUGIN_SKILL_NAMES = Object.freeze(['computer-use', 'browser', 'browser-use']);
 export const FORBIDDEN_BROWSER_AUTOMATION_RE = /\b(playwright|chrome\s+mcp|browser\s+use|selenium|puppeteer)\b/i;
@@ -308,7 +308,7 @@ export const ROUTES = [
     context7Policy: 'optional',
     reasoningPolicy: 'high',
     stopGate: 'team-gate.json',
-    cliEntrypoint: 'sks team "task" [executor:5 reviewer:6 user:1] | sks team log|tail|watch|lane|status|event|message|cleanup-tmux',
+    cliEntrypoint: 'sks team "task" [executor:5 reviewer:6 user:1] | sks team log|tail|watch|lane|status|event|message|open-tmux|attach-tmux|cleanup-tmux',
     examples: ['$Team executor:5 agree on the best plan and implement it', '$From-Chat-IMG 채팅+첨부 이미지 작업 지시서']
   },
   {
@@ -548,7 +548,7 @@ export const COMMAND_CATALOG = [
   { name: 'validate-artifacts', usage: 'sks validate-artifacts [mission-id|latest] [--json]', description: 'Validate schema-backed mission artifacts for work orders, effort decisions, visual maps, dogfood reports, skills, mistake memory, Team dashboard state, and Honest Mode.' },
   { name: 'wiki', usage: 'sks wiki coords|pack|refresh|prune|validate ...', description: 'Build, refresh, prune, and validate RGBA/trig LLM Wiki context packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
   { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
-  { name: 'team', usage: 'sks team "task" [executor:5 reviewer:6 user:1]|log|tail|watch|lane|status|dashboard|event|message|cleanup-tmux ...', description: 'Create and observe a scout-first Team mission with at least five reviewer/QA validation lanes, color-coded tmux lanes, transcript messages, and cleanup-aware follow panes.' },
+  { name: 'team', usage: 'sks team "task" [executor:5 reviewer:6 user:1]|log|tail|watch|lane|status|dashboard|event|message|open-tmux|attach-tmux|cleanup-tmux ...', description: 'Create and observe a scout-first Team mission with at least five reviewer/QA validation lanes, current-session managed tmux lanes when available, transcript messages, and cleanup-aware follow panes.' },
   { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
   { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
   { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },

package/src/core/team-live.mjs

@@ -151,6 +151,7 @@ export function defaultTeamDashboard(id, prompt, opts = {}) {
       status: `sks team status ${id}`,
       log: `sks team log ${id}`,
       tail: `sks team tail ${id}`,
+      open_tmux: `sks team open-tmux ${id}`,
       watch: `sks team watch ${id}`,
       lane: `sks team lane ${id} --agent <agent> --follow`,
       event: `sks team event ${id} --agent <agent> --phase <phase> --message "..."`,
@@ -204,6 +205,7 @@ ${prompt}
 sks team status ${id}
 sks team log ${id}
 sks team tail ${id}
+sks team open-tmux ${id}
 sks team watch ${id}
 sks team lane ${id} --agent analysis_scout_1 --follow
 sks team event ${id} --agent analysis_scout_1 --phase parallel_analysis_scouting --message "mapped repo slice"
@@ -313,7 +315,7 @@ export function parseTeamSpecArgs(args = []) {
       i++;
       continue;
     }
-    if (arg === '--json' || arg === '--open-tmux' || arg === '--tmux-open' || arg === '--no-open-tmux' || arg === '--no-tmux' || arg === '--no-attach') continue;
+    if (arg === '--json' || arg === '--open-tmux' || arg === '--tmux-open' || arg === '--no-open-tmux' || arg === '--no-tmux' || arg === '--no-attach' || arg === '--separate-session' || arg === '--new-session' || arg === '--legacy-team-session' || arg === '--no-dynamic-team-tmux') continue;
     cleanArgs.push(args[i]);
   }
   return { cleanArgs, ...normalizeTeamSpec({ roleCounts, agentSessions: explicitSession }) };
@@ -444,6 +446,7 @@ export async function appendTeamEvent(dir, event) {
     dashboard.agents[agent].last_seen = record.ts;
     await writeJsonAtomic(files.dashboard, dashboard);
   }
+  await reconcileTeamTmuxFromEvent(dir, record).catch(() => null);
   const current = await readText(files.live, teamLiveMarkdown('unknown', 'unknown'));
   const target = record.to ? ` -> ${record.to}` : '';
   const line = `\n- ${record.ts} [${record.phase || 'general'}] ${record.agent || 'unknown'}${target}: ${record.message || ''}${record.artifact ? ` (${record.artifact})` : ''}\n`;
@@ -451,6 +454,22 @@ export async function appendTeamEvent(dir, event) {
   return record;
 }
 
+async function reconcileTeamTmuxFromEvent(dir, record = {}) {
+  if (!process.env.TMUX || String(process.env.SKS_TMUX_EVENT_RECONCILE || '1') === '0') return null;
+  if (record.type === 'tmux_lane_opened') return null;
+  const missionId = path.basename(dir);
+  const root = path.resolve(dir, '..', '..', '..');
+  const cockpitState = await readJson(path.join(root, '.sneakoscope', 'state', 'tmux-cockpit.json'), {}).catch(() => ({}));
+  if (!cockpitState?.missions?.[missionId]) return null;
+  const plan = await readJson(path.join(dir, 'team-plan.json'), null).catch(() => null);
+  if (!plan) return null;
+  const { reconcileTmuxTeamCockpit } = await import('./tmux-ui.mjs');
+  const phase = String(record.phase || '');
+  const type = String(record.type || '');
+  const close = /^session_cleanup$|^team_cleanup$|^cleanup$/i.test(phase) || /^cleanup$/i.test(type);
+  return reconcileTmuxTeamCockpit({ root, missionId, plan, close, plannedFallback: false });
+}
+
 export async function readTeamControl(dir) {
   return readJson(teamLogPaths(dir).control, defaultTeamControl(path.basename(dir)));
 }
@@ -466,7 +485,7 @@ export async function requestTeamSessionCleanup(dir, opts = {}) {
     cleanup_requested_at: opts.ts || nowIso(),
     cleanup_requested_by: opts.agent || 'parent_orchestrator',
     cleanup_reason: opts.reason || 'Team session cleanup requested.',
-    final_message: opts.finalMessage || 'Team session ended. Lane follow loops may stop; tmux panes remain user-controlled.'
+    final_message: opts.finalMessage || 'Team session ended. Lane follow loops may stop; managed tmux Team panes may close.'
   };
   await writeJsonAtomic(files.control, next);
   return next;
@@ -486,7 +505,7 @@ export function renderTeamCleanupSummary(control = {}) {
     `Requested by: ${control.cleanup_requested_by || 'unknown'}`,
     `Reason: ${control.cleanup_reason || 'Team session cleanup requested.'}`,
     '',
-    control.final_message || 'Team session ended. tmux panes remain user-controlled.'
+    control.final_message || 'Team session ended. managed tmux Team panes may close.'
   ].join('\n');
 }
 
@@ -569,6 +588,8 @@ export async function renderTeamWatch(dir, opts = {}) {
     '',
     '## Split-Screen Map',
     '- This overview pane follows the whole mission transcript.',
+    '- Run `sks team open-tmux ...` to materialize or reopen the split-pane Team tmux view for an existing mission.',
+    '- Inside an SKS-owned tmux session, Team panes are reconciled in the current window and managed panes may close as agent lanes finish.',
     '- Neighbor tmux panes follow individual `sks team lane ... --agent <name>` views.',
     '- Use `sks team event ...` to mirror scout, debate, executor, review, and verification status into the live panes.',
     '- Use `sks team message ... --from <agent> --to <agent|all>` for bounded inter-agent communication in transcript/lane views.',

package/src/core/tmux-ui.mjs

@@ -7,7 +7,7 @@ import { getCodexInfo } from './codex-adapter.mjs';
 import { codexAppIntegrationStatus, formatCodexAppStatus } from './codex-app.mjs';
 import { REQUIRED_CODEX_MODEL, forceGpt55CodexArgs } from './codex-model-guard.mjs';
 import { MIN_TEAM_REVIEWER_LANES } from './team-review-policy.mjs';
-import { appendTeamEvent } from './team-live.mjs';
+import { appendTeamEvent, readTeamControl, readTeamDashboard, teamCleanupRequested } from './team-live.mjs';
 
 const SKS_FIGLET_FONT = 'Standard';
 
@@ -97,6 +97,28 @@ export function tmuxTeamStatePath(root = process.cwd()) {
   return path.join(path.resolve(root || process.cwd()), '.sneakoscope', 'state', 'tmux-team-sessions.json');
 }
 
+export function tmuxCockpitStatePath(root = process.cwd()) {
+  return path.join(path.resolve(root || process.cwd()), '.sneakoscope', 'state', 'tmux-cockpit.json');
+}
+
+const TERMINAL_TEAM_AGENT_STATUSES = new Set([
+  'agent_closed',
+  'agent_done',
+  'cancelled',
+  'canceled',
+  'cleanup',
+  'cleanup_requested',
+  'closed',
+  'complete',
+  'completed',
+  'done',
+  'ended',
+  'failed',
+  'stopped',
+  'terminal',
+  'tmux_lane_closed'
+]);
+
 export function isTmuxShellSession(env = process.env) {
   return Boolean(String(env.TMUX || '').trim());
 }
@@ -298,7 +320,8 @@ export function formatTmuxBanner(status = null) {
     '  sks                 open or attach the default tmux Codex CLI session',
     '  sks tmux open       open or attach a tmux Codex CLI session with explicit flags',
     '  sks --mad           open one-shot MAD full-access auto-review tmux session',
-    '  sks team "task"     prepare Team mission and open the tmux multi-pane live view',
+    '  sks team "task"     prepare Team mission and reconcile Team panes in the current SKS tmux session when available',
+    '  sks team open-tmux latest  reopen current-session panes, or use --separate-session for the legacy view',
     '',
     'Useful terminal commands:',
     '  sks commands',
@@ -342,6 +365,116 @@ async function tmuxWindowTarget(bin, session) {
   return windowId || fallback;
 }
 
+async function currentTmuxTarget(bin, env = process.env) {
+  if (!isTmuxShellSession(env)) return { ok: false, reason: 'not running inside tmux' };
+  const run = await tmuxRun(bin, ['display-message', '-p', '#{session_name}\t#{window_id}\t#{pane_id}'], { timeoutMs: 5000, maxOutputBytes: 4096 });
+  if (run.code !== 0) return { ok: false, reason: run.stderr || run.stdout || 'tmux display-message failed' };
+  const [session, windowId, paneId] = String(run.stdout || '').trim().split('\t');
+  if (!session || !windowId) return { ok: false, reason: 'tmux did not report current session/window' };
+  return { ok: true, session: sanitizeTmuxSessionName(session), window_id: windowId, pane_id: paneId || null };
+}
+
+async function isRecordedSksTmuxSession(root, session) {
+  const state = await readJson(tmuxStatePath(root), {}).catch(() => ({}));
+  const sessions = state.sessions && typeof state.sessions === 'object' ? state.sessions : {};
+  const record = sessions[sanitizeTmuxSessionName(session)] || null;
+  if (!record) return { ok: false, reason: 'current tmux session is not recorded as an SKS session' };
+  const recordRoot = path.resolve(record.root || root || process.cwd());
+  const resolvedRoot = path.resolve(root || process.cwd());
+  if (recordRoot !== resolvedRoot) return { ok: false, reason: `recorded SKS session belongs to ${recordRoot}` };
+  return { ok: true, record };
+}
+
+function isTerminalTeamAgentStatus(status = '') {
+  const normalized = String(status || '').trim().toLowerCase();
+  return TERMINAL_TEAM_AGENT_STATUSES.has(normalized) || /(?:^|_)(?:done|complete|completed|closed|cleanup|cancelled|canceled|failed|ended|stopped)(?:_|$)/.test(normalized);
+}
+
+function teamCockpitAgentIds(plan = {}, dashboard = null, control = null, opts = {}) {
+  if (teamCleanupRequested(control)) return [];
+  const visible = teamViewAgentIds(plan).filter((id) => id && id !== 'mission_overview');
+  const agents = dashboard?.agents && typeof dashboard.agents === 'object' ? dashboard.agents : null;
+  if (!agents) return opts.plannedFallback ? visible : [];
+  const active = [];
+  for (const id of visible) {
+    const entry = agents[id] || {};
+    const status = String(entry.status || '').trim().toLowerCase();
+    if (!status || status === 'pending') continue;
+    if (isTerminalTeamAgentStatus(status)) continue;
+    active.push(id);
+  }
+  if (!active.length && opts.plannedFallback) return visible;
+  return uniqueAgentIds(active);
+}
+
+function teamCockpitLanes(plan = {}, dashboard = null, control = null, opts = {}) {
+  const agents = teamCockpitAgentIds(plan, dashboard, control, opts);
+  if (!agents.length) return [];
+  const overview = { agent: 'mission_overview', role: 'overview', command: teamOverviewCommand(opts.root, opts.missionId), style: teamLaneStyle('mission_overview'), title: teamLaneTitle('mission_overview') };
+  return [
+    overview,
+    ...agents.map((agent) => {
+      const style = teamLaneStyle(agent);
+      return {
+        agent,
+        role: style.role,
+        command: teamAgentCommand(opts.root, opts.missionId, agent, teamLanePhase(agent)),
+        style,
+        title: teamLaneTitle(agent)
+      };
+    })
+  ];
+}
+
+function parseTmuxPaneLines(stdout = '') {
+  return String(stdout || '').split(/\r?\n/).filter(Boolean).map((line) => {
+    const [pane_id, title, command, managed, mission_id, agent, role] = line.split('\t');
+    return {
+      pane_id,
+      title: title || '',
+      command: command || '',
+      managed: managed === '1' || managed === 'true',
+      mission_id: mission_id || '',
+      agent: agent || '',
+      role: role || ''
+    };
+  }).filter((pane) => /^%\d+$/.test(pane.pane_id || ''));
+}
+
+async function listTmuxWindowPanes(bin, windowId) {
+  const format = ['#{pane_id}', '#{pane_title}', '#{pane_current_command}', '#{@sks_team_managed}', '#{@sks_mission_id}', '#{@sks_agent_id}', '#{@sks_lane_role}'].join('\t');
+  const run = await tmuxRun(bin, ['list-panes', '-t', windowId, '-F', format], { timeoutMs: 5000, maxOutputBytes: 32 * 1024 });
+  if (run.code !== 0) return { ok: false, panes: [], stderr: run.stderr || run.stdout || 'tmux list-panes failed' };
+  return { ok: true, panes: parseTmuxPaneLines(run.stdout) };
+}
+
+async function setTmuxPaneUserOptions(bin, paneId, options = {}) {
+  const applied = [];
+  const failed = [];
+  for (const [key, value] of Object.entries(options)) {
+    const run = await tmuxRun(bin, ['set-option', '-pt', paneId, key, String(value)], { timeoutMs: 5000 });
+    const command = [path.basename(bin), 'set-option', '-pt', paneId, key, String(value)].join(' ');
+    if (run.code === 0) applied.push(command);
+    else failed.push({ command, stderr: run.stderr || run.stdout || 'tmux set-option failed' });
+  }
+  return { applied, failed };
+}
+
+async function writeTmuxCockpitRecord(root, record = {}) {
+  if (!record.mission_id || !record.session) return null;
+  const statePath = tmuxCockpitStatePath(root);
+  const state = await readJson(statePath, {}).catch(() => ({}));
+  const now = nowIso();
+  const nextRecord = { ...record, schema_version: 1, root: path.resolve(root || process.cwd()), updated_at: now };
+  const missions = state.missions && typeof state.missions === 'object' ? state.missions : {};
+  await writeJsonAtomic(statePath, {
+    schema_version: 1,
+    updated_at: now,
+    missions: { ...missions, [record.mission_id]: nextRecord }
+  });
+  return nextRecord;
+}
+
 function tmuxLayoutName(value = 'tiled') {
   const layout = String(value || 'tiled').trim();
   return /^(tiled|even-horizontal|even-vertical|main-horizontal|main-horizontal-mirrored|main-vertical|main-vertical-mirrored)$/.test(layout)
@@ -558,6 +691,97 @@ function teamLanePhase(agentId = '') {
   return 'team';
 }
 
+export async function reconcileTmuxTeamCockpit({ root, missionId, plan = {}, promptFile = null, dashboard = undefined, control = undefined, close = false, plannedFallback = false, env = process.env, tmux = null } = {}) {
+  const resolvedRoot = path.resolve(root || await sksRoot());
+  const id = missionId || 'latest';
+  if (String(env.SKS_TMUX_DYNAMIC_TEAM || '1') === '0') return { ok: false, skipped: true, reason: 'SKS_TMUX_DYNAMIC_TEAM=0' };
+  const tmuxBin = tmux?.bin || await findTmuxBin() || 'tmux';
+  const target = await currentTmuxTarget(tmuxBin, env);
+  if (!target.ok) return { ok: false, skipped: true, reason: target.reason };
+  const ownership = await isRecordedSksTmuxSession(resolvedRoot, target.session);
+  if (!ownership.ok) return { ok: false, skipped: true, session: target.session, reason: ownership.reason };
+  const missionDir = path.join(resolvedRoot, '.sneakoscope', 'missions', id);
+  const loadedDashboard = dashboard === undefined ? await readTeamDashboard(missionDir).catch(() => null) : dashboard;
+  const loadedControl = control === undefined ? await readTeamControl(missionDir).catch(() => null) : control;
+  const lanes = close
+    ? []
+    : teamCockpitLanes(plan, loadedDashboard, loadedControl, { root: resolvedRoot, missionId: id, plannedFallback });
+  const desiredAgents = new Set(lanes.map((lane) => lane.agent));
+  const paneList = await listTmuxWindowPanes(tmuxBin, target.window_id);
+  if (!paneList.ok) return { ok: false, skipped: false, session: target.session, window_id: target.window_id, reason: paneList.stderr };
+  const managed = paneList.panes.filter((pane) => pane.managed && pane.mission_id === id);
+  const byAgent = new Map();
+  for (const pane of managed) {
+    if (pane.agent && !byAgent.has(pane.agent)) byAgent.set(pane.agent, pane);
+  }
+  const opened = [];
+  const closed = [];
+  const failed = [];
+  for (const pane of managed) {
+    if (!desiredAgents.has(pane.agent)) {
+      const kill = await tmuxRun(tmuxBin, ['kill-pane', '-t', pane.pane_id], { timeoutMs: 5000 });
+      if (kill.code === 0) closed.push({ pane_id: pane.pane_id, agent: pane.agent, role: pane.role });
+      else failed.push({ action: 'kill-pane', pane_id: pane.pane_id, agent: pane.agent, stderr: kill.stderr || kill.stdout || 'tmux kill-pane failed' });
+    }
+  }
+  for (const lane of lanes) {
+    if (byAgent.has(lane.agent)) continue;
+    const split = await tmuxRun(tmuxBin, ['split-window', '-t', target.window_id, '-d', '-P', '-F', '#{pane_id}', '-c', resolvedRoot, lane.command || 'pwd'], { timeoutMs: 5000, maxOutputBytes: 4096 });
+    const pane_id = paneId(split.stdout);
+    if (split.code !== 0 || !pane_id) {
+      failed.push({ action: 'split-window', agent: lane.agent, role: lane.role, stderr: split.stderr || split.stdout || 'tmux split-window failed' });
+      continue;
+    }
+    const optionResult = await setTmuxPaneUserOptions(tmuxBin, pane_id, {
+      '@sks_team_managed': '1',
+      '@sks_mission_id': id,
+      '@sks_agent_id': lane.agent,
+      '@sks_lane_role': lane.role || teamLaneStyle(lane.agent).role
+    });
+    failed.push(...optionResult.failed.map((entry) => ({ action: 'set-option', agent: lane.agent, role: lane.role, ...entry })));
+    opened.push({ pane_id, agent: lane.agent, role: lane.role, title: lane.title });
+  }
+  let relayout = null;
+  if (opened.length || closed.length) {
+    const tiled = await tmuxRun(tmuxBin, ['select-layout', '-t', target.window_id, 'tiled'], { timeoutMs: 5000 });
+    const even = await tmuxRun(tmuxBin, ['select-layout', '-t', target.window_id, '-E'], { timeoutMs: 5000 });
+    relayout = { ok: tiled.code === 0 && even.code === 0, tiled: tiled.code, even: even.code };
+  }
+  const nextPanes = [
+    ...managed.filter((pane) => desiredAgents.has(pane.agent) && !closed.some((entry) => entry.pane_id === pane.pane_id)),
+    ...opened
+  ];
+  await writeTmuxCockpitRecord(resolvedRoot, {
+    mission_id: id,
+    session: target.session,
+    window_id: target.window_id,
+    main_pane_id: target.pane_id,
+    mode: 'current_session_dynamic_panes',
+    desired_lane_count: lanes.length,
+    panes: nextPanes,
+    opened,
+    closed,
+    failed
+  }).catch(() => null);
+  return {
+    ok: failed.length === 0,
+    mode: 'current_session_dynamic_panes',
+    session: target.session,
+    window_id: target.window_id,
+    main_pane_id: target.pane_id,
+    desired_lane_count: lanes.length,
+    opened_lane_count: opened.length,
+    closed_lane_count: closed.length,
+    managed_lane_count: nextPanes.length,
+    opened,
+    closed,
+    failed,
+    relayout,
+    attach_command: `tmux attach-session -t ${target.session}`,
+    cleanup_policy: 'managed Team panes are reconciled in the current SKS tmux session; main Codex pane is never killed'
+  };
+}
+
 export async function launchTmuxTeamView({ root, missionId, plan = {}, promptFile = null, json = false, attach = false, args = [] } = {}) {
   const launch = await buildTmuxLaunchPlan({ root, session: `sks-team-${missionId}` });
   const visibleAgents = teamViewAgentIds(plan);
@@ -594,6 +818,60 @@ export async function launchTmuxTeamView({ root, missionId, plan = {}, promptFil
     attach_command: launch.attach_command
   };
   if (json || !launch.ready) return result;
+  const wantsSeparateSession = args.includes('--separate-session') || args.includes('--new-session') || args.includes('--legacy-team-session') || args.includes('--no-dynamic-team-tmux');
+  if (!wantsSeparateSession) {
+    const cockpit = await reconcileTmuxTeamCockpit({ root: launch.root, missionId, plan, promptFile, plannedFallback: true });
+    result.dynamic_cockpit = cockpit;
+    if (cockpit.ok) {
+      result.created = true;
+      result.opened = cockpit;
+      result.session = cockpit.session;
+      result.workspace = cockpit.session;
+      result.opened_lane_count = cockpit.managed_lane_count;
+      result.all_lanes_opened = cockpit.desired_lane_count === cockpit.managed_lane_count;
+      result.ready = true;
+      result.attach_command = cockpit.attach_command;
+      result.cleanup_policy = cockpit.cleanup_policy;
+      result.split_ui = {
+        ...splitUi,
+        mode: cockpit.mode,
+        current_session: true,
+        window_id: cockpit.window_id,
+        user_attach_command: cockpit.attach_command
+      };
+      await writeTmuxTeamRecord(launch.root, {
+        mission_id: missionId,
+        session: cockpit.session,
+        attach_command: cockpit.attach_command,
+        split_ui: result.split_ui,
+        cleanup_policy: result.cleanup_policy,
+        panes: cockpit.opened || [],
+        lanes: lanes.map((entry) => ({
+          agent: entry.agent,
+          role: entry.style?.role || teamLaneStyle(entry.agent).role,
+          style: entry.style || teamLaneStyle(entry.agent),
+          title: entry.title || teamLaneTitle(entry.agent)
+        })),
+        mode: cockpit.mode,
+        window_id: cockpit.window_id
+      }).catch(() => null);
+      if (cockpit.opened?.length) {
+        const dir = path.join(launch.root, '.sneakoscope', 'missions', missionId);
+        if (await exists(dir)) {
+          for (const lane of cockpit.opened) {
+            if (!lane.agent || lane.agent === 'mission_overview') continue;
+            await appendTeamEvent(dir, {
+              agent: lane.agent,
+              phase: teamLanePhase(lane.agent),
+              type: 'tmux_lane_opened',
+              message: `tmux pane opened for ${lane.agent}; following live lane activity in the current SKS tmux session.`
+            }).catch(() => null);
+          }
+        }
+      }
+      return result;
+    }
+  }
   const panes = lanes.map((lane, index) => ({ cwd: launch.root, command: lane.command, focused: index === 0, role: lane.role, title: lane.title, vertical: index > 1 }));
   const created = await createTmuxSession(launch, panes, { layout: 'tiled', recreate: true });
   result.created = Boolean(created.ok);
@@ -685,8 +963,9 @@ export async function cleanupTmuxTeamView({ root, missionId = 'latest', closeSes
   const resolvedRoot = path.resolve(root || await sksRoot());
   const record = await readTmuxTeamRecord(resolvedRoot, missionId);
   if (!record?.session) return { ok: false, skipped: true, reason: 'no recorded tmux Team session', mission_id: missionId };
+  const dynamicCleanup = await reconcileTmuxTeamCockpit({ root: resolvedRoot, missionId: record.mission_id || missionId, close: true }).catch((err) => ({ ok: false, skipped: true, reason: err.message || 'dynamic tmux cleanup failed' }));
   let killed_session = false;
-  if (closeSession || closeSession === true) {
+  if ((closeSession || closeSession === true) && record.mode !== 'current_session_dynamic_panes') {
     const tmuxBin = await findTmuxBin() || 'tmux';
     const kill = await tmuxRun(tmuxBin, ['kill-session', '-t', record.session], { timeoutMs: 5000 });
     killed_session = kill.code === 0;
@@ -699,9 +978,14 @@ export async function cleanupTmuxTeamView({ root, missionId = 'latest', closeSes
     attach_command: record.attach_command,
     close_session: Boolean(closeSession),
     killed_session,
-    requested_close_surfaces: closeSession ? 1 : 0,
-    closed_surfaces: killed_session ? 1 : 0,
-    reason: closeSession ? 'tmux kill-session requested for recorded Team session.' : 'cleanup marks the SKS tmux Team record complete; panes remain user-controlled.'
+    dynamic_cleanup: dynamicCleanup,
+    requested_close_surfaces: closeSession ? 1 : (dynamicCleanup?.closed_lane_count || 0),
+    closed_surfaces: killed_session ? 1 : (dynamicCleanup?.closed_lane_count || 0),
+    reason: dynamicCleanup?.ok
+      ? 'cleanup closed managed Team panes in the current SKS tmux session.'
+      : closeSession
+        ? 'tmux kill-session requested for recorded Team session.'
+        : 'cleanup marks the SKS tmux Team record complete; panes remain user-controlled.'
   };
 }