sneakoscope 0.6.76 → 0.6.77

package/README.md

@@ -201,6 +201,10 @@ sks team log latest
 
 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 cmux Team workspace with split live lanes when cmux is available. `sks team dashboard` renders the cockpit panes for mission overview, agent lanes, task DAG, QA/dogfood, artifacts/evidence, and performance.
 
+The cmux Team workspace is a live orchestration screen: 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. SKS colors and labels lanes by role, so scouts, planning/debate voices, executors, reviewers, and safety lanes are visually distinct while the same evidence is mirrored into `team-transcript.jsonl`, `team-live.md`, and `team-dashboard.json`.
+
+When the Team route reaches `session_cleanup`, SKS collapses the cmux workspace back to the overview pane and marks the workspace complete. You can also run `sks team cleanup-cmux <mission-id|latest>` manually, or `sks team cleanup-cmux latest --close-workspace` when you want the whole Team workspace closed.
+
 ### QA, Goal, Research, DB, Wiki, GX
 
 ```sh

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.6.76",
+  "version": "0.6.77",
   "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/main.mjs

@@ -40,7 +40,7 @@ import { buildPromptContext } from '../core/prompt-context-builder.mjs';
 import { renderTeamDashboardState, writeTeamDashboardState } from '../core/team-dashboard-renderer.mjs';
 import { GOAL_WORKFLOW_ARTIFACT } from '../core/goal-workflow.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
-import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, buildCmuxNewWorkspaceArgs, cmuxSurfaceRefFromText, cmuxWorkspaceRef, cmuxWorkspaceRefFromText, cmuxReadiness, cmuxStatusKind, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, matchingCmuxWorkspaces, parseCmuxWorkspaceList, platformCmuxInstallHint, readCmuxWorkspaceRecord, runCmuxStatus, sanitizeCmuxWorkspaceName, writeCmuxWorkspaceRecord } from '../core/cmux-ui.mjs';
+import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, buildCmuxNewWorkspaceArgs, cmuxSurfaceRefFromText, cmuxWorkspaceRef, cmuxWorkspaceRefFromText, cmuxReadiness, cmuxStatusKind, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, matchingCmuxWorkspaces, parseCmuxWorkspaceList, platformCmuxInstallHint, readCmuxWorkspaceRecord, runCmuxStatus, sanitizeCmuxWorkspaceName, teamLaneStyle, writeCmuxWorkspaceRecord } from '../core/cmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 import { buildTeamPlan, codeStructureCommand, defaultBeta, defaultVGraph, evalCommand, gcCommand, goalCommand, gxCommand, hproofCommand, memoryCommand, migrateWikiContextPack, parseTeamCreateArgs, perfCommand, profileCommand, projectWikiClaims, qaLoopCommand, researchCommand, statsCommand, team, teamWorkflowMarkdown, validateArtifactsCommand, wikiCommand, wikiVoxelRowCount, writeWikiContextPack } from './maintenance-commands.mjs';
 
@@ -2700,7 +2700,10 @@ async function selftest() {
   if (!roleTeamPlan.roster.debate_team.some((agent) => /inconvenience/.test(agent.persona))) throw new Error('selftest failed: user friction persona missing from debate team');
   const cmuxTeam = await launchCmuxTeamView({ root: tmp, missionId: teamId, plan: roleTeamPlan, json: true });
   if (!cmuxTeam.agents?.length || !cmuxTeam.agents.some((entry) => entry.agent === 'analysis_scout_1') || !cmuxTeam.agents.every((entry) => String(entry.command || '').includes('team lane') && String(entry.command || '').includes('--agent'))) throw new Error('selftest failed: Team cmux view did not expose agent live lanes');
-  const cmuxTeamWorkspaceArgs = buildCmuxNewWorkspaceArgs({ root: tmp, workspace: `sks-team-${teamId}` }, cmuxTeam.agents[0].command);
+  if (!cmuxTeam.overview?.command?.includes('team watch') || !cmuxTeam.lanes?.some((entry) => entry.role === 'overview') || !cmuxTeam.lanes?.some((entry) => entry.agent === 'analysis_scout_1')) throw new Error('selftest failed: Team cmux view did not expose orchestration overview plus agent lanes');
+  if (teamLaneStyle('analysis_scout_1').role !== 'scout' || teamLaneStyle('executor_1').role !== 'execution' || teamLaneStyle('reviewer_1').role !== 'review') throw new Error('selftest failed: Team cmux role palette did not classify lane roles');
+  if (cmuxTeam.cleanup_policy !== 'collapse-agent-lanes-to-overview' || !cmuxTeam.lanes.every((entry) => entry.style?.color && entry.title)) throw new Error('selftest failed: Team cmux view did not expose color/title metadata and cleanup policy');
+  const cmuxTeamWorkspaceArgs = buildCmuxNewWorkspaceArgs({ root: tmp, workspace: `sks-team-${teamId}` }, cmuxTeam.overview.command);
   if (!cmuxTeamWorkspaceArgs.includes('--name') || !cmuxTeamWorkspaceArgs.includes(`sks-team-${teamId}`)) throw new Error('selftest failed: Team cmux workspace is not named for visibility');
   if (routeReasoning(routePrompt('$Research frontier idea'), '$Research frontier idea').effort !== 'xhigh') throw new Error('selftest failed: research reasoning not xhigh');
   if (routeReasoning(routePrompt('$From-Chat-IMG 채팅 이미지 작업'), '$From-Chat-IMG 채팅 이미지 작업').effort !== 'xhigh') throw new Error('selftest failed: From-Chat-IMG reasoning not xhigh');

package/src/cli/maintenance-commands.mjs

@@ -17,7 +17,7 @@ import { contextCapsule } from '../core/triwiki-attention.mjs';
 import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../core/wiki-coordinate.mjs';
 import { ALLOWED_REASONING_EFFORTS, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, ROUTES, hasFromChatImgSignal, routePrompt, stackCurrentDocsPolicy, triwikiContextTracking } from '../core/routes.mjs';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
-import { appendTeamEvent, formatRoleCounts, initTeamLive, normalizeTeamSpec, parseTeamSpecArgs, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane } from '../core/team-live.mjs';
+import { appendTeamEvent, formatRoleCounts, initTeamLive, normalizeTeamSpec, parseTeamSpecArgs, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane, renderTeamWatch } from '../core/team-live.mjs';
 import { ARTIFACT_FILES, writeValidationReport } from '../core/artifact-schemas.mjs';
 import { writeEffortDecision } from '../core/effort-orchestrator.mjs';
 import { createWorkOrderLedger, writeWorkOrderLedger } from '../core/work-order-ledger.mjs';
@@ -27,7 +27,7 @@ import { runPerfBench } from '../core/perf-bench.mjs';
 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 { launchCmuxTeamView } from '../core/cmux-ui.mjs';
+import { cleanupCmuxTeamView, launchCmuxTeamView } from '../core/cmux-ui.mjs';
 import { writeSkillForgeReport } from '../core/skill-forge.mjs';
 import { writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
 import { scanDbSafety } from '../core/db-safety.mjs';
@@ -1171,13 +1171,13 @@ export async function gxCommand(sub, args) {
 }
 
 export async function team(args) {
-  const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event']);
+  const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'cleanup-cmux']);
   if (teamSubcommands.has(args[0])) return teamCommand(args[0], args.slice(1));
   const opts = parseTeamCreateArgs(args);
   const { prompt, agentSessions, roleCounts, roster } = opts;
   if (!prompt) {
     console.error('Usage: sks team "task" [executor:5 reviewer:2 user:1] [--agents N] [--json]');
-    console.error('       sks team log|tail|watch|lane|status [mission-id|latest]');
+    console.error('       sks team log|tail|watch|lane|status|cleanup-cmux [mission-id|latest]');
     console.error('       sks team event [mission-id|latest] --agent <name> --phase <phase> --message "..."');
     process.exitCode = 1;
     return;
@@ -1507,15 +1507,35 @@ async function teamCommand(sub, args) {
       process.exitCode = 1;
       return;
     }
+    const phase = readFlagValue(args, '--phase', 'general');
     const record = await appendTeamEvent(dir, {
       agent: readFlagValue(args, '--agent', 'parent_orchestrator'),
-      phase: readFlagValue(args, '--phase', 'general'),
+      phase,
       type: readFlagValue(args, '--type', 'status'),
       artifact: readFlagValue(args, '--artifact', ''),
       message
     });
+    const cmuxCleanup = /^session_cleanup$|^team_cleanup$|^cleanup$/i.test(String(phase || ''))
+      ? await cleanupCmuxTeamView({ root, missionId: id, closeWorkspace: flag(args, '--close-workspace') }).catch((err) => ({ ok: false, reason: err.message || 'cmux 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 (cmuxCleanup) {
+      if (cmuxCleanup.ok) console.log(`cmux cleanup: collapsed ${cmuxCleanup.closed_surfaces || 0} agent pane(s), kept overview ${cmuxCleanup.kept_surface || cmuxCleanup.workspace_ref}`);
+      else console.log(`cmux cleanup: skipped (${cmuxCleanup.reason || 'not available'})`);
+    }
+    return;
+  }
+  if (sub === 'cleanup-cmux') {
+    const cleanup = await cleanupCmuxTeamView({ root, missionId: id, closeWorkspace: flag(args, '--close-workspace') || flag(args, '--close') });
+    if (flag(args, '--json')) return console.log(JSON.stringify(cleanup, null, 2));
+    if (!cleanup.ok) {
+      console.error(`cmux cleanup skipped: ${cleanup.reason || 'not available'}`);
+      process.exitCode = cleanup.skipped ? 0 : 2;
+      return;
+    }
+    if (cleanup.close_workspace) console.log(`cmux cleanup: closed Team workspace ${cleanup.workspace_ref}`);
+    else console.log(`cmux cleanup: collapsed ${cleanup.closed_surfaces}/${cleanup.requested_close_surfaces} agent pane(s), kept overview ${cleanup.kept_surface || cleanup.workspace_ref}`);
     return;
   }
   if (sub === 'status') {
@@ -1573,15 +1593,26 @@ async function teamCommand(sub, args) {
   if (sub === 'tail' || sub === 'watch') {
     const lines = readFlagValue(args, '--lines', '20');
     const printTail = async () => {
+      if (sub === 'watch' && !flag(args, '--raw')) {
+        if (flag(args, '--follow') && process.stdout.isTTY) console.clear();
+        console.log(await renderTeamWatch(dir, { missionId: id, lines: Number(lines) }));
+        return;
+      }
       for (const line of await readTeamTranscriptTail(dir, Number(lines))) console.log(line);
     };
     await printTail();
     if (sub === 'watch' && flag(args, '--follow')) {
-      let last = (await readTeamTranscriptTail(dir, Number(lines))).join('\n');
+      let last = flag(args, '--raw')
+        ? (await readTeamTranscriptTail(dir, Number(lines))).join('\n')
+        : await renderTeamWatch(dir, { missionId: id, lines: Number(lines) });
       for (;;) {
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        const next = (await readTeamTranscriptTail(dir, Number(lines))).join('\n');
+        const next = flag(args, '--raw')
+          ? (await readTeamTranscriptTail(dir, Number(lines))).join('\n')
+          : await renderTeamWatch(dir, { missionId: id, lines: Number(lines) });
         if (next !== last) {
+          if (process.stdout.isTTY) console.clear();
+          else console.log('\n--- team watch update ---\n');
           console.log(next);
           last = next;
         }

package/src/core/cmux-ui.mjs

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { exists, nowIso, packageRoot, readJson, runProcess, sha256, sksRoot, which, writeJsonAtomic } from './fsx.mjs';
 import { getCodexInfo } from './codex-adapter.mjs';
 import { codexAppIntegrationStatus, formatCodexAppStatus } from './codex-app.mjs';
@@ -90,6 +90,10 @@ export function cmuxWorkspaceStatePath(plan = {}) {
   return path.join(path.resolve(plan.root || process.cwd()), '.sneakoscope', 'state', 'cmux-workspaces.json');
 }
 
+export function cmuxTeamStatePath(root = process.cwd()) {
+  return path.join(path.resolve(root || process.cwd()), '.sneakoscope', 'state', 'cmux-team-workspaces.json');
+}
+
 export function cmuxWorkspaceStateKey(plan = {}) {
   const root = path.resolve(plan.root || process.cwd());
   const workspace = sanitizeCmuxWorkspaceName(plan.workspace || defaultCmuxWorkspaceName(root));
@@ -189,6 +193,23 @@ export function cmuxBinaryCandidates() {
   return Array.from(new Set(candidates));
 }
 
+function cmuxAppExecutableCandidates() {
+  if (process.platform !== 'darwin') return [];
+  const envApps = String(process.env.SKS_CMUX_APP_PATHS || '')
+    .split(path.delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  const appBundles = [
+    ...envApps,
+    '/Applications/cmux.app',
+    '/Applications/Cmux.app',
+    '/Applications/CMUX.app',
+    path.join(process.env.HOME || '', 'Applications', 'cmux.app'),
+    '/opt/homebrew/Caskroom/cmux/latest/cmux.app'
+  ].filter(Boolean);
+  return Array.from(new Set(appBundles.map((app) => path.join(app, 'Contents', 'MacOS', 'cmux'))));
+}
+
 export async function cmuxAvailable() {
   const bin = await findCmuxBinary();
   if (!bin) return { ok: false, bin: null, version: null, executable_ok: false, error: 'cmux CLI not found' };
@@ -267,14 +288,59 @@ export function codexLaunchCommand(root, codexBin, codexArgs = []) {
   ].join('; ');
 }
 
+function echoLinesCommand(lines = []) {
+  return lines.map((line) => String(line) ? `echo ${shellEscape(line)}` : 'echo').join('; ');
+}
+
+export const CMUX_TEAM_LANE_STYLES = Object.freeze({
+  overview: Object.freeze({ role: 'overview', label: 'overview', color_name: 'Charcoal', color: '#3E4B5E', icon: 'layout-dashboard' }),
+  scout: Object.freeze({ role: 'scout', label: 'scout', color_name: 'Aqua', color: '#0E6B8C', icon: 'search' }),
+  planning: Object.freeze({ role: 'planning', label: 'plan', color_name: 'Amber', color: '#7D6608', icon: 'messages-square' }),
+  execution: Object.freeze({ role: 'execution', label: 'exec', color_name: 'Green', color: '#196F3D', icon: 'hammer' }),
+  review: Object.freeze({ role: 'review', label: 'review', color_name: 'Crimson', color: '#922B21', icon: 'shield-check' }),
+  safety: Object.freeze({ role: 'safety', label: 'safety', color_name: 'Magenta', color: '#AD1457', icon: 'database' })
+});
+
+export function teamLaneStyle(agentId = '') {
+  const id = String(agentId || '').toLowerCase();
+  if (!id || id === 'mission_overview' || id === 'overview') return CMUX_TEAM_LANE_STYLES.overview;
+  if (/analysis|scout/.test(id)) return CMUX_TEAM_LANE_STYLES.scout;
+  if (/debate|consensus|planner|user/.test(id)) return CMUX_TEAM_LANE_STYLES.planning;
+  if (/db|safety/.test(id)) return CMUX_TEAM_LANE_STYLES.safety;
+  if (/review|qa|validation/.test(id)) return CMUX_TEAM_LANE_STYLES.review;
+  if (/executor|implementation|worker|developer/.test(id)) return CMUX_TEAM_LANE_STYLES.execution;
+  return CMUX_TEAM_LANE_STYLES.planning;
+}
+
+function teamLaneTitle(agentId = '') {
+  const style = teamLaneStyle(agentId);
+  return `${style.label}: ${String(agentId || 'mission_overview')}`.slice(0, 80);
+}
+
+function cmuxStatusKey(agentId = '') {
+  return sanitizeCmuxWorkspaceName(`sks-${String(agentId || 'overview').toLowerCase()}`).slice(0, 40);
+}
+
 export function teamAgentCommand(root, missionId, agentId, phase) {
+  const style = teamLaneStyle(agentId);
   return [
-    `printf '%s\\n' ${shellEscape(`${SKS_CMUX_LOGO}\n\nTeam mission: ${missionId}\nAgent: ${agentId}\nPhase: ${phase}\n`)}`,
+    'clear',
+    echoLinesCommand([...SKS_CMUX_LOGO.split('\n'), '', `Team mission: ${missionId}`, `Agent: ${agentId}`, `Lane: ${style.label} (${style.color_name} ${style.color})`, `Phase: ${phase}`, '']),
     `cd ${shellEscape(root)}`,
     `node ${shellEscape(path.join(packageRoot(), 'bin', 'sks.mjs'))} team lane ${shellEscape(missionId)} --agent ${shellEscape(agentId)} --phase ${shellEscape(phase)} --follow --lines 12`
   ].join('; ');
 }
 
+export function teamOverviewCommand(root, missionId) {
+  const style = teamLaneStyle('mission_overview');
+  return [
+    'clear',
+    echoLinesCommand([...SKS_CMUX_LOGO.split('\n'), '', `Team mission: ${missionId}`, 'View: live orchestration overview', `Lane: ${style.label} (${style.color_name} ${style.color})`, '']),
+    `cd ${shellEscape(root)}`,
+    `node ${shellEscape(path.join(packageRoot(), 'bin', 'sks.mjs'))} team watch ${shellEscape(missionId)} --follow --lines 18`
+  ].join('; ');
+}
+
 export async function buildCmuxLaunchPlan(opts = {}) {
   const root = path.resolve(opts.root || await sksRoot());
   const workspace = sanitizeCmuxWorkspaceName(opts.workspace || opts.session || defaultCmuxWorkspaceName(root));
@@ -491,6 +557,14 @@ async function ensureCmuxDaemonReady(cmux = {}) {
       last = await cmuxSocketProbe(cmux.bin);
       if (last.ok) return { ...cmux, ok: true, error: null };
     }
+    if (process.env.SKS_CMUX_SOCKET_ALLOW_ALL !== '0') {
+      await restartCmuxApp({ socketMode: 'allowAll' });
+      for (let i = 0; i < 8; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 750));
+        last = await cmuxSocketProbe(cmux.bin);
+        if (last.ok) return { ...cmux, ok: true, error: null, socket_mode: 'allowAll' };
+      }
+    }
   }
   return { ok: false, error: last.error || 'cmux socket did not become ready' };
 }
@@ -505,7 +579,7 @@ function isRecoverableCmuxSocketError(error) {
   return /socket|broken pipe|receive timeout|connection refused/i.test(String(error || ''));
 }
 
-async function restartCmuxApp() {
+async function restartCmuxApp(opts = {}) {
   if (process.platform !== 'darwin') return { ok: false, reason: 'not_macos' };
   const quit = await runProcess('osascript', ['-e', 'tell application "cmux" to quit'], { timeoutMs: 8000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
   if (quit.code !== 0) {
@@ -513,6 +587,21 @@ async function restartCmuxApp() {
   }
   await new Promise((resolve) => setTimeout(resolve, 1500));
   await removeStaleCmuxSocket().catch(() => null);
+  if (opts.socketMode) return openCmuxAppWithSocketMode(opts.socketMode);
+  return openCmuxApp();
+}
+
+async function openCmuxAppWithSocketMode(socketMode) {
+  for (const exe of cmuxAppExecutableCandidates()) {
+    if (!await exists(exe)) continue;
+    const child = spawn(exe, [], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, CMUX_SOCKET_MODE: socketMode }
+    });
+    child.unref();
+    return { ok: true, mode: socketMode, executable: exe };
+  }
   return openCmuxApp();
 }
 
@@ -524,7 +613,7 @@ async function removeStaleCmuxSocket() {
 }
 
 export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFile = null, json = false } = {}) {
-  const launch = await buildCmuxLaunchPlan({ root, workspace: `sks-team-${missionId}` });
+  const launch = await buildCmuxLaunchPlan({ root, workspace: `sks-team-${missionId}`, wakeCmux: true });
   const agents = [
     ...(plan.roster?.analysis_team || []),
     ...(plan.roster?.debate_team || []),
@@ -541,18 +630,26 @@ export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFil
   }
   const commands = uniqueAgents.slice(0, Math.max(1, plan.agent_session_count || 3)).map((agentId, index) => ({
     agent: agentId,
-    command: teamAgentCommand(launch.root, missionId, agentId, index === 0 ? 'analysis' : 'team', promptFile)
+    command: teamAgentCommand(launch.root, missionId, agentId, index === 0 ? 'analysis' : 'team', promptFile),
+    style: teamLaneStyle(agentId),
+    title: teamLaneTitle(agentId)
   }));
-  const result = { ready: launch.ready, cmux: launch.cmux, workspace: launch.workspace, agents: commands, blockers: launch.blockers };
+  const overview = { agent: 'mission_overview', role: 'overview', command: teamOverviewCommand(launch.root, missionId), style: teamLaneStyle('mission_overview'), title: teamLaneTitle('mission_overview') };
+  const lanes = [overview, ...commands.map((entry) => ({ ...entry, role: entry.style.role }))];
+  const result = { ready: launch.ready, cmux: launch.cmux, workspace: launch.workspace, overview, agents: commands, lanes, cleanup_policy: 'collapse-agent-lanes-to-overview', blockers: launch.blockers };
   if (json || !launch.ready) return result;
-  const first = commands[0]?.command || teamAgentCommand(launch.root, missionId, 'parent_orchestrator', 'team', promptFile);
+  const first = overview.command;
   const created = spawnSync(launch.cmux.bin, buildCmuxNewWorkspaceArgs(launch, first), { encoding: 'utf8', stdio: 'pipe' });
   result.created = created.status === 0;
   result.stdout = created.stdout || '';
   result.stderr = created.stderr || '';
-  const workspaceRef = cmuxWorkspaceRefFromText(`${created.stdout || ''}\n${created.stderr || ''}`);
+  const createdText = `${created.stdout || ''}\n${created.stderr || ''}`;
+  const workspaceRef = cmuxWorkspaceRefFromText(createdText);
+  let overviewSurfaceRef = cmuxSurfaceRefFromText(createdText);
   if (workspaceRef) {
+    overviewSurfaceRef ||= firstCmuxSurfaceRef(launch.cmux.bin, workspaceRef);
     result.workspace_ref = workspaceRef;
+    if (overviewSurfaceRef) result.overview.surface_ref = overviewSurfaceRef;
     await writeCmuxWorkspaceRecord(launch, { ref: workspaceRef, name: launch.workspace, description: cmuxWorkspaceDescription(launch), cwd: launch.root }).catch(() => null);
     const selected = await runProcess(launch.cmux.bin, ['select-workspace', '--workspace', workspaceRef], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
     result.selected = selected.code === 0;
@@ -564,7 +661,7 @@ export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFil
     if (!workspaceRef) result.blockers = [...(result.blockers || []), 'cmux new-workspace did not return a workspace ref'];
     return result;
   }
-  for (const entry of commands.slice(1)) {
+  for (const entry of commands) {
     const split = spawnSync(launch.cmux.bin, ['new-split', 'right', '--workspace', workspaceRef], { encoding: 'utf8', stdio: 'pipe' });
     const splitText = `${split.stdout || ''}\n${split.stderr || ''}`;
     const surfaceRef = cmuxSurfaceRefFromText(splitText);
@@ -574,6 +671,8 @@ export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFil
       ok: split.status === 0 && Boolean(surfaceRef),
       pane_ref: paneRef,
       surface_ref: surfaceRef,
+      style: entry.style,
+      title: entry.title,
       stdout: split.stdout || '',
       stderr: split.stderr || ''
     };
@@ -585,10 +684,35 @@ export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFil
     }
     result.splits.push(splitResult);
   }
+  const customizationLanes = [
+    { ...overview, surface_ref: overviewSurfaceRef },
+    ...result.splits.map((entry) => ({ agent: entry.agent, surface_ref: entry.surface_ref, pane_ref: entry.pane_ref, style: entry.style, title: entry.title }))
+  ];
+  result.customization = await applyCmuxTeamCustomization(launch.cmux.bin, workspaceRef, customizationLanes);
+  await writeCmuxTeamRecord(launch.root, {
+    mission_id: missionId,
+    workspace: launch.workspace,
+    workspace_ref: workspaceRef,
+    overview_surface_ref: overviewSurfaceRef || null,
+    cleanup_policy: result.cleanup_policy,
+    lanes: customizationLanes.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),
+      surface_ref: entry.surface_ref || null,
+      pane_ref: entry.pane_ref || null
+    }))
+  }).catch(() => null);
   result.split_count = result.splits.filter((entry) => entry.ok && entry.send_ok).length;
-  const expectedSplits = Math.max(0, commands.length - 1);
+  const expectedSplits = commands.length;
   result.opened_lane_count = 1 + result.split_count;
   result.all_lanes_opened = result.created && result.selected !== false && result.split_count === expectedSplits;
+  result.screen_read_checks = readCmuxLaneScreens(launch.cmux.bin, workspaceRef, [
+    { agent: 'mission_overview', surface_ref: overviewSurfaceRef },
+    ...result.splits.map((entry) => ({ agent: entry.agent, surface_ref: entry.surface_ref }))
+  ]);
+  result.screen_read_ok = result.screen_read_checks.some((entry) => entry.ok);
   result.ready = Boolean(result.ready && result.all_lanes_opened);
   if (!result.all_lanes_opened) {
     result.blockers = [
@@ -600,6 +724,135 @@ export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFil
   return result;
 }
 
+async function applyCmuxTeamCustomization(bin, workspaceRef, lanes = []) {
+  if (!bin || !workspaceRef) return { ok: false, skipped: true, reason: 'missing cmux binary or workspace ref', operations: [] };
+  const operations = [];
+  const pushRun = async (label, args) => {
+    const run = await runProcess(bin, args, { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+    operations.push({ label, args, ok: run.code === 0, stdout: run.stdout || '', stderr: run.stderr || '' });
+    return run.code === 0;
+  };
+  const overview = lanes.find((lane) => (lane.agent || '') === 'mission_overview') || lanes[0] || {};
+  const overviewStyle = overview.style || teamLaneStyle('mission_overview');
+  await pushRun('workspace-color', ['workspace-action', '--workspace', workspaceRef, '--action', 'set-color', '--color', overviewStyle.color]);
+  await pushRun('workspace-status', ['set-status', 'sks-team', 'Team live', '--icon', overviewStyle.icon, '--color', overviewStyle.color, '--workspace', workspaceRef]);
+  await pushRun('workspace-progress', ['set-progress', '0.15', '--label', 'Team running', '--workspace', workspaceRef]);
+  for (const lane of lanes) {
+    const style = lane.style || teamLaneStyle(lane.agent);
+    if (lane.surface_ref) await pushRun(`rename-${lane.agent}`, ['rename-tab', '--workspace', workspaceRef, '--surface', lane.surface_ref, '--title', lane.title || teamLaneTitle(lane.agent)]);
+    await pushRun(`status-${lane.agent}`, ['set-status', cmuxStatusKey(lane.agent), lane.title || teamLaneTitle(lane.agent), '--icon', style.icon, '--color', style.color, '--workspace', workspaceRef]);
+  }
+  return { ok: operations.some((entry) => entry.ok), operations };
+}
+
+async function writeCmuxTeamRecord(root, record = {}) {
+  if (!record.mission_id || !record.workspace_ref) return null;
+  const statePath = cmuxTeamStatePath(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;
+}
+
+async function readCmuxTeamRecord(root, missionId) {
+  const state = await readJson(cmuxTeamStatePath(root), {}).catch(() => ({}));
+  const missions = state.missions && typeof state.missions === 'object' ? state.missions : {};
+  if (missionId && missionId !== 'latest') return missions[missionId] || null;
+  const records = Object.values(missions).filter((entry) => entry && typeof entry === 'object');
+  records.sort((a, b) => String(b.updated_at || '').localeCompare(String(a.updated_at || '')));
+  return records[0] || null;
+}
+
+export async function cleanupCmuxTeamView({ root, missionId = 'latest', closeWorkspace = false } = {}) {
+  const resolvedRoot = path.resolve(root || await sksRoot());
+  const record = await readCmuxTeamRecord(resolvedRoot, missionId);
+  if (!record?.workspace_ref) return { ok: false, skipped: true, reason: 'no recorded cmux Team workspace', mission_id: missionId };
+  const cmux = await cmuxReadiness({ wake: true }).catch((err) => ({ ok: false, error: err.message || 'cmux readiness failed' }));
+  if (!cmux.ok) return { ok: false, workspace_ref: record.workspace_ref, mission_id: record.mission_id, reason: cmux.error || 'cmux not ready' };
+  const operations = [];
+  const run = async (label, args) => {
+    const out = await runProcess(cmux.bin, args, { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+    operations.push({ label, ok: out.code === 0, stdout: out.stdout || '', stderr: out.stderr || '' });
+    return out.code === 0;
+  };
+  if (closeWorkspace) {
+    const closed = await run('close-workspace', ['close-workspace', '--workspace', record.workspace_ref]);
+    return { ok: closed, mission_id: record.mission_id, workspace_ref: record.workspace_ref, close_workspace: true, closed_workspace: closed, operations };
+  }
+  let overviewSurfaceRef = record.overview_surface_ref || record.lanes?.find((lane) => lane.agent === 'mission_overview')?.surface_ref || null;
+  let agentLanes = (record.lanes || []).filter((lane) => lane.surface_ref && lane.surface_ref !== overviewSurfaceRef && lane.agent !== 'mission_overview');
+  if (!overviewSurfaceRef) {
+    const agentRefs = new Set(agentLanes.map((lane) => lane.surface_ref));
+    overviewSurfaceRef = listCmuxWorkspaceSurfacesSync(cmux.bin, record.workspace_ref).find((surfaceRef) => !agentRefs.has(surfaceRef)) || null;
+    agentLanes = (record.lanes || []).filter((lane) => lane.surface_ref && lane.surface_ref !== overviewSurfaceRef && lane.agent !== 'mission_overview');
+  }
+  let closed = 0;
+  for (const lane of agentLanes) {
+    if (await run(`close-${lane.agent}`, ['close-surface', '--workspace', record.workspace_ref, '--surface', lane.surface_ref])) closed += 1;
+  }
+  const completeStyle = CMUX_TEAM_LANE_STYLES.execution;
+  if (overviewSurfaceRef) await run('rename-overview-complete', ['rename-tab', '--workspace', record.workspace_ref, '--surface', overviewSurfaceRef, '--title', `complete: ${record.mission_id}`.slice(0, 80)]);
+  await run('status-complete', ['set-status', 'sks-team', 'Team complete', '--icon', 'check-circle', '--color', completeStyle.color, '--workspace', record.workspace_ref]);
+  await run('progress-complete', ['set-progress', '1.0', '--label', 'Team complete', '--workspace', record.workspace_ref]);
+  await run('select-workspace', ['select-workspace', '--workspace', record.workspace_ref]);
+  await writeCmuxTeamRecord(resolvedRoot, { ...record, cleanup_completed_at: nowIso(), closed_agent_surfaces: closed }).catch(() => null);
+  return {
+    ok: true,
+    mission_id: record.mission_id,
+    workspace_ref: record.workspace_ref,
+    close_workspace: false,
+    kept_surface: overviewSurfaceRef,
+    requested_close_surfaces: agentLanes.length,
+    closed_surfaces: closed,
+    operations
+  };
+}
+
+function readCmuxLaneScreens(bin, workspaceRef, lanes = []) {
+  return lanes.map((lane) => {
+    const args = ['read-screen', '--workspace', workspaceRef, '--lines', '6'];
+    if (lane.surface_ref) args.splice(3, 0, '--surface', lane.surface_ref);
+    const read = spawnSync(bin, args, { encoding: 'utf8', stdio: 'pipe' });
+    const text = `${read.stdout || ''}\n${read.stderr || ''}`.trim();
+    return {
+      agent: lane.agent,
+      surface_ref: lane.surface_ref || null,
+      ok: read.status === 0 && Boolean(text),
+      preview: text.slice(0, 1000),
+      error: read.status === 0 ? null : text || 'cmux read-screen failed'
+    };
+  });
+}
+
+function firstCmuxSurfaceRef(bin, workspaceRef) {
+  return listCmuxWorkspaceSurfacesSync(bin, workspaceRef)[0] || '';
+}
+
+function listCmuxWorkspaceSurfacesSync(bin, workspaceRef) {
+  if (!bin || !workspaceRef) return [];
+  const panes = spawnSync(bin, ['list-panes', '--workspace', workspaceRef], { encoding: 'utf8', stdio: 'pipe' });
+  if (panes.status !== 0) return [];
+  const paneRefs = Array.from(new Set(String(`${panes.stdout || ''}\n${panes.stderr || ''}`).match(/\bpane:\d+\b/g) || []));
+  const surfaces = [];
+  for (const paneRef of paneRefs) {
+    const run = spawnSync(bin, ['list-pane-surfaces', '--workspace', workspaceRef, '--pane', paneRef], { encoding: 'utf8', stdio: 'pipe' });
+    if (run.status !== 0) continue;
+    for (const surfaceRef of String(`${run.stdout || ''}\n${run.stderr || ''}`).match(/\bsurface:\d+\b/g) || []) {
+      if (!surfaces.includes(surfaceRef)) surfaces.push(surfaceRef);
+    }
+  }
+  return surfaces;
+}
+
 export async function runCmuxStatus(args = [], opts = {}) {
   const once = args.includes('--once') || !args.includes('--watch');
   do {

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.6.76';
+export const PACKAGE_VERSION = '0.6.77';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/init.mjs

@@ -486,7 +486,7 @@ function codexAppQuickReference(scope, commandPrefix) {
     `Runtime root: ${commandPrefix} root shows whether SKS is using the nearest project root or the per-user global SKS runtime root; outside any project marker, runtime commands use the global root instead of writing .sneakoscope into the current random directory.`,
     `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 lanes: ${commandPrefix} team lane latest --agent analysis_scout_1 --follow shows one agent's status, assigned runtime tasks, recent agent events, and fallback global tail.`,
+    `Team cmux view: ${commandPrefix} team "task" opens a live orchestration workspace with 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, and fallback global tail; ${commandPrefix} team cleanup-cmux latest collapses agent panes back to the overview.`,
     `Runtime: open Codex App once, then run ${commandPrefix} bootstrap, ${commandPrefix} deps check, or ${commandPrefix} deps install cmux.`,
     `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/team-live.mjs

@@ -376,6 +376,43 @@ export async function renderTeamAgentLane(dir, opts = {}) {
   ].join('\n');
 }
 
+export async function renderTeamWatch(dir, opts = {}) {
+  const lines = Math.max(1, Number(opts.lines) || 20);
+  const dashboard = await readTeamDashboard(dir);
+  const runtime = await readJson(path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT), null);
+  const missionId = opts.missionId || dashboard?.mission_id || runtime?.mission_id || path.basename(dir);
+  const agents = Object.entries(dashboard?.agents || {});
+  const visibleAgents = agents
+    .filter(([name]) => name !== 'parent_orchestrator')
+    .slice(0, Math.max(3, Number(dashboard?.agent_session_count) || 3));
+  const events = (await readTeamTranscriptTail(dir, lines)).map(parseTranscriptLine).filter(Boolean);
+  const runtimeTasks = Array.isArray(runtime?.tasks) ? runtime.tasks : Array.isArray(runtime) ? runtime : [];
+  return [
+    '# SKS Team Live Orchestration',
+    '',
+    `Mission: ${missionId}`,
+    `Updated: ${dashboard?.updated_at || 'unknown'}`,
+    `Agent session budget: ${dashboard?.agent_session_count || 'unknown'}`,
+    dashboard?.role_counts ? `Role counts: ${formatRoleCounts(dashboard.role_counts)}` : null,
+    '',
+    '## Split-Screen Map',
+    '- This overview pane follows the whole mission transcript.',
+    '- Neighbor cmux 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.',
+    '',
+    '## Visible Agent Lanes',
+    ...(visibleAgents.length
+      ? visibleAgents.map(([name, status]) => `- ${name}: ${status.status || 'pending'} | ${status.phase || 'unknown'} | last_seen:${status.last_seen || 'never'}`)
+      : ['- No agent lanes registered yet.']),
+    '',
+    '## Runtime Task Snapshot',
+    ...(runtimeTasks.length ? formatRuntimeTasks(runtimeTasks.slice(0, 8)) : ['- team-runtime-tasks.json not available yet.']),
+    '',
+    '## Recent Mission Events',
+    ...(events.length ? events.map(formatTranscriptEvent) : ['- No transcript events yet.'])
+  ].filter((line) => line !== null).join('\n');
+}
+
 function normalizeEvent(event = {}) {
   return {
     ts: event.ts || nowIso(),