sneakoscope 0.6.62 → 0.6.66

package/README.md

@@ -2,120 +2,415 @@
 
 ![](https://github.com/mandarange/Sneakoscope-Codex/raw/dev/docs/assets/sneakoscope-codex-logo.png)
 
-Codex CLI/App harness for `$` routes, cmux-native CLI workspaces, Team/Ralph/QA/Research, Context7, Honest Mode, DB safety, TriWiki, Codex App skills, and release readiness.
+Sneakoscope Codex (`sks`, displayed as `ㅅㅋㅅ`) is a Codex CLI/App harness for repeatable agent workflows. It adds terminal commands, Codex App `$` prompt commands, cmux-native CLI workspaces, Team/Ralph/QA/Research routes, Context7 evidence checks, DB safety, TriWiki context tracking, Honest Mode, and release-readiness gates.
 
-Install: `npm i -g sneakoscope && sks bootstrap`
-Fallback: `npx -y -p sneakoscope sks bootstrap`
-Project: `npm i -D sneakoscope && npx sks setup --install-scope project`
+## Quick Start
 
-Discover: `sks commands`, `sks dollar-commands`, `sks usage <topic>`
-Check: `sks deps check`, `sks doctor --fix`, `sks selftest --mock`
+Install globally, initialize the current project, then open the cmux runtime:
 
-## What It Adds
+```sh
+npm i -g sneakoscope
+sks bootstrap
+sks
+```
+
+If you only want a one-shot run without keeping `sks` installed globally:
+
+```sh
+npx -y -p sneakoscope sks bootstrap
+```
 
-Sneakoscope (`sks`, displayed as `ㅅㅋㅅ`) wraps Codex with a repeatable control surface:
+For a repo-local install:
+
+```sh
+npm i -D sneakoscope
+npx sks setup --install-scope project
+```
+
+Check that the install is usable:
+
+```sh
+sks deps check
+sks codex-app check
+sks dollar-commands
+sks selftest --mock
+```
+
+## What Sneakoscope Adds
 
 | Area | What it does |
 | --- | --- |
-| Codex App commands | Installs generated skills so `$Team`, `$DFix`, `$QA-LOOP`, `$Ralph`, `$DB`, `$Wiki`, `$Help`, and related routes are discoverable in prompt workflows. |
-| CLI commands | Provides `sks commands`, `sks dollar-commands`, `sks usage <topic>`, bootstrap, setup, doctor, deps, selftest, wiki, team, QA, Ralph, DB, and GX commands. |
-| cmux runtime | Opens Codex CLI through `sks`/`sks cmux`, exposes one-shot full-access high mode with `sks --mad --high`, and opens Team missions with cmux multi-line agent lanes when cmux is available. |
-| Team orchestration | Routes substantial code work through ambiguity removal, scouts, TriWiki refresh, debate, consensus, concrete runtime task graph/inboxes, implementation, review, integration, reflection, and Honest Mode. |
-| Ralph | Seals a decision contract up front, then continues without more user questions by using the agreed decision ladder. |
-| QA loop | Dogfoods UI/API behavior with safety boundaries, evidence capture, safe remediation, and focused rechecks. |
-| TriWiki | Keeps `.sneakoscope/wiki/context-pack.json` as the context SSOT, with refresh, pack, prune, validate, active attention ranking, and hydratable source-backed claims. |
-| Context7 | Requires current external library/API/framework docs for routes whose correctness depends on live package or platform behavior. |
-| DB safety | Treats SQL, migrations, Supabase, RLS, and destructive operations as high risk; defaults to inspection and guarded local/branch-safe migration work. |
-| Honest Mode | Finishes work with a claim/evidence pass that separates verified facts, unsupported claims, blocked checks, and not-applicable items. |
-| GX visual context | Generates deterministic visual context cartridges for structured visual review and drift checks. |
-| Research loops | Supports Research and AutoResearch workflows with hypotheses, experiments, falsification, novelty ledgers, SEO/GEO, and evidence-backed conclusions. |
-| Release hygiene | Checks versioning, changelog, package contents, tarball size, syntax, selftests, and dry-run packaging before publish. |
+| CLI runtime | `sks`, `sks cmux`, and `sks --mad` open Codex CLI in a cmux workspace. |
+| Codex App commands | Installs generated skills so `$Team`, `$DFix`, `$QA-LOOP`, `$Ralph`, `$DB`, `$Wiki`, `$Help`, and related routes are visible in prompt workflows. |
+| Team orchestration | Runs substantial work through ambiguity handling, scouts, TriWiki refresh, debate, runtime task graphs, worker inboxes, implementation, review, cleanup, reflection, and Honest Mode. |
+| QA loop | Dogfoods UI/API behavior with safety gates, Browser/Computer evidence, safe fixes, and rechecks. |
+| Ralph | Clarifies once, seals a decision contract, then continues without repeatedly asking the user. |
+| TriWiki | Maintains `.sneakoscope/wiki/context-pack.json` as the context SSOT with `attention.use_first` and `attention.hydrate_first`. |
+| Context7 | Requires current docs for external packages, APIs, MCPs, SDKs, and framework/runtime behavior when correctness depends on current guidance. |
+| DB safety | Treats SQL, migrations, Supabase, RLS, and destructive operations as high risk. |
+| Release hygiene | Checks versioning, changelog, package contents, tarball size, syntax, selftests, and dry-run publishing. |
 
-## Prompt `$` Commands
+## Requirements
 
-Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.
+- Node.js `>=20.11`
+- npm
+- Codex CLI for terminal workflows
+- Codex App for app-facing workflows and first-party Browser Use / Computer Use parity
+- cmux for the CLI-first runtime
+- Context7 MCP for current-docs-gated routes
 
-| Prompt | Purpose |
-| --- | --- |
-| `$Team` | Default route for code-changing work and substantial implementation. |
-| `$From-Chat-IMG` | Team alias for chat screenshot plus original attachment intake. |
-| `$DFix` | Tiny design/content fixes: labels, copy, colors, spacing, translation. |
-| `$Answer` | Answer-only route when no implementation should start. |
-| `$SKS` | Setup, status, usage, and Sneakoscope workflow help. |
-| `$QA-LOOP` | UI/API dogfooding, safe fixes, and rechecks. |
-| `$Ralph` | Clarify once, seal a decision contract, then execute. |
-| `$Research` | Frontier-style research with hypotheses and falsification. |
-| `$AutoResearch` | Iterative improve-test-keep/discard optimization loop. |
-| `$DB` | Database and Supabase safety checks. |
-| `$MAD-SKS` | Explicit scoped DB authorization modifier; combine it with another `$` route when needed, widened Supabase MCP permissions last only for that invocation, and table deletion requires a short user confirmation timeout. |
-| `$GX` | Deterministic visual context generation and validation. |
-| `$Wiki` | TriWiki refresh, pack, prune, validate, and maintenance. |
-| `$Help` | Installed command and workflow explanation. |
-
-Run `sks dollar-commands` to verify the terminal and Codex App command surfaces agree.
-
-## Terminal Examples
+On macOS, `sks --mad` can install cmux through Homebrew when cmux is missing. You can also install it manually:
+
+```sh
+brew tap manaflow-ai/cmux
+brew install --cask cmux
+```
+
+If the CLI is not on `PATH`, SKS also checks the app bundle path:
+
+```sh
+/Applications/cmux.app/Contents/Resources/bin/cmux
+/Applications/cmux.app/Contents/MacOS/cmux
+```
+
+`sks --mad` is stricter than the normal runtime path:
+
+- Checks npm for a newer `sneakoscope` before launch and asks whether to update when the terminal can answer y/n.
+- Installs the latest Codex CLI with `npm i -g @openai/codex@latest` when it is missing and you approve or pass `--yes`.
+- Installs or upgrades the latest cmux cask through Homebrew when cmux is missing or not launchable.
+- Re-probes the real cmux binary after install instead of trusting Homebrew's success text alone.
+- Wakes cmux and retries the socket probe; if the socket is broken, SKS attempts a cmux app restart during that explicit launch.
+
+## Installation
+
+### Global Install
+
+Use this when you want `sks` available from any repo:
+
+```sh
+npm i -g sneakoscope
+sks bootstrap
+```
+
+`sks bootstrap` initializes the current project, installs Codex App skills/hooks/config, checks Context7/Codex App/cmux readiness, and prints a ready status.
+
+### One-Shot Install
+
+Use this when you do not want to keep a global install:
+
+```sh
+npx -y -p sneakoscope sks bootstrap
+```
+
+`npx` fetches the package into npm's cache and runs the binary for that command. This is useful for first-time setup or CI-style verification.
+
+### Project Install
+
+Use this when a repo should pin Sneakoscope as a development dependency:
 
 ```sh
+npm i -D sneakoscope
+npx sks setup --install-scope project
+```
+
+Project installs are useful when a team wants a repeatable harness version checked through `package-lock.json`.
+
+### Source Checkout
+
+Use this when developing Sneakoscope itself:
+
+```sh
+git clone https://github.com/mandarange/Sneakoscope-Codex.git
+cd Sneakoscope-Codex
+npm install
+npm install -g .
+sks --version
+```
+
+## Terminal CLI Usage
+
+Use terminal commands when you want to inspect, set up, verify, or start a CLI-first workspace.
+
+### Discovery
+
+```sh
+sks commands
 sks usage install
 sks usage team
-sks usage qa-loop
 sks usage codex-app
+sks dollar-commands
+sks --version
+```
+
+### Setup And Repair
+
+```sh
+sks bootstrap
+sks deps check
+sks deps install cmux
+sks codex-app check
+sks doctor --fix
+sks fix-path
+```
+
+### Open Codex CLI With cmux
+
+```sh
+sks
 sks cmux check
-sks --mad --high
-sks setup --install-scope project
+sks cmux status --once
+```
+
+`sks` opens a cmux workspace for Codex CLI when running in an interactive terminal. `sks cmux check` is diagnostic and prints readiness without starting a workspace.
+
+### MAD cmux Workspace
+
+```sh
+sks --mad
+sks --mad --yes
+```
+
+This creates/uses the `sks-mad-high` Codex profile for a one-shot full-access, high-reasoning cmux workspace with `approval_policy = "on-request"` and `approvals_reviewer = "auto_review"`. It is scoped to that explicit command and does not change normal SKS/DB safety defaults.
+
+Before launching, SKS checks whether a newer `sneakoscope` exists on npm. In an interactive terminal it prompts:
+
+```text
+SKS 0.x.y -> 0.x.z update before MAD launch? [Y/n]
+```
+
+Answer `y` to install `sneakoscope@latest`, then rerun `sks --mad`. Answer `n` to continue with the current version. Use `--yes` to approve missing dependency installs automatically.
+
+### Team Missions
+
+```sh
+sks team "implement this feature" executor:3 reviewer:1
+sks team watch latest
+sks team status latest
+sks team log latest
+```
+
+Team mode prepares the mission, records live events, compiles runtime tasks and worker inboxes, and opens cmux live lanes when cmux is available.
+
+### QA, Ralph, Research, DB, Wiki, GX
+
+```sh
+sks qa-loop prepare "http://localhost:3000"
+sks qa-loop run latest --max-cycles 2
+sks ralph prepare "migrate this workflow without asking after prepare"
+sks research prepare "evaluate this approach"
+sks db scan --json
 sks wiki refresh
 sks wiki validate .sneakoscope/wiki/context-pack.json
-sks versioning status
+sks gx init homepage
+sks gx render homepage --format html
 ```
 
-Route examples:
+## Codex App Usage
+
+Sneakoscope has two surfaces:
+
+- Terminal commands such as `sks deps check`, `sks team "task"`, and `sks --mad`
+- Codex App prompt commands such as `$Team`, `$DFix`, `$QA-LOOP`, and `$Wiki`
+
+After installing, run:
 
 ```sh
-sks team "implement this" executor:3 reviewer:1
-sks team watch <mission-id>
-sks qa-loop prepare
-sks qa-loop run
-sks ralph prepare
-sks ralph run
-sks db scan
-sks gx init
+sks bootstrap
+sks codex-app check
+sks dollar-commands
 ```
 
-## Workflow Rules
+Then open Codex App and use prompt commands directly in the chat. Examples:
 
-For code work, Sneakoscope defaults to Team. The normal flow is: remove ambiguity that can change scope or safety, read/validate TriWiki, consume `attention.use_first` for compact high-trust context, hydrate `attention.hydrate_first` from source before risky decisions, gather current source evidence, synthesize consensus, compile a concrete runtime task graph plus worker inboxes, implement bounded changes, refresh/validate context after meaningful findings, run relevant checks, then finish with reflection and Honest Mode.
+```text
+$Team implement the checkout fix and verify it
+$DFix change this label and spacing only
+$QA-LOOP dogfood localhost:3000 and fix safe issues
+$Ralph clarify once, then finish the migration without more questions
+$Wiki refresh and validate the context pack
+$DB inspect this migration for destructive risk
+```
 
-For tiny text/design edits use `$DFix`. For questions that should not change files use `$Answer`.
+Generated app files include:
 
-## Codex App Surface
+| Path | Purpose |
+| --- | --- |
+| `.codex/SNEAKOSCOPE.md` | Codex App quick reference and route guidance. |
+| `.agents/skills/` | Generated skill instructions for `$` commands. |
+| `.codex/hooks.json` | Stop/finalization hooks for Honest Mode and completion summaries. |
+| `.codex/config.toml` | Codex profiles, agents, and MCP configuration. |
+| `.sneakoscope/` | Runtime state, missions, wiki packs, policies, and artifacts. |
 
-`sks bootstrap` and `sks setup` install `.codex/SNEAKOSCOPE.md`, generated `.agents/skills`, `.codex/hooks.json`, route instructions for `$` commands, and user-home skill state for first-install discoverability.
+Use `sks dollar-commands` to confirm that terminal discovery and Codex App prompt commands agree.
 
-After install, check:
+## Prompt `$` Commands
+
+Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.
+
+| Prompt | Use when |
+| --- | --- |
+| `$Team` | You want implementation, code changes, or substantial repo work. |
+| `$From-Chat-IMG` | You have a chat screenshot plus original attachments and want each visible request mapped to work. |
+| `$DFix` | You need a tiny design/content edit such as copy, label, color, spacing, or translation. |
+| `$Answer` | You want an answer only and no implementation should start. |
+| `$SKS` | You need setup, status, usage, or workflow help. |
+| `$QA-LOOP` | You want UI/API dogfooding, safe fixes, and rechecks. |
+| `$Ralph` | You want one prepare-time clarification pass, then no more user questions. |
+| `$Research` | You need frontier-style research with hypotheses and falsification. |
+| `$AutoResearch` | You want iterative improve/test/keep-or-discard optimization. |
+| `$DB` | You need database, Supabase, migration, SQL, or MCP safety checks. |
+| `$MAD-SKS` | You explicitly authorize a scoped high-risk DB permission modifier for the active invocation only. |
+| `$GX` | You need deterministic visual context cartridges. |
+| `$Wiki` | You want TriWiki refresh, pack, prune, validate, or maintenance. |
+| `$Help` | You want installed command and workflow explanation. |
+
+## Common Workflows
+
+### First Install Checklist
 
 ```sh
+npm i -g sneakoscope
+sks bootstrap
+sks deps check
+sks codex-app check
 sks dollar-commands
-sks usage codex-app
+sks selftest --mock
+```
+
+### Start A CLI Workspace
+
+```sh
+sks cmux check
+sks
 ```
 
-## Release Checks
+For the high-reasoning full-access profile:
 
-Before publish:
+```sh
+sks --mad
+```
+
+### Use Codex App `$Team`
+
+```text
+$Team implement the requested change, update docs if needed, and verify with the relevant tests
+```
+
+Team mode records a mission under `.sneakoscope/missions/`, keeps a live transcript, uses TriWiki context, and finishes with evidence and Honest Mode.
+
+### Dogfood A UI Or API
+
+```sh
+sks qa-loop prepare "http://localhost:3000"
+sks qa-loop run latest --max-cycles 2
+sks qa-loop status latest
+```
+
+Use `$QA-LOOP` in Codex App when Browser Use or Computer Use evidence should be part of the workflow.
+
+### Refresh Context Before Risky Work
+
+```sh
+sks wiki refresh
+sks wiki validate .sneakoscope/wiki/context-pack.json
+```
+
+TriWiki is the long-running context source of truth. It keeps compact high-trust recall in `attention.use_first` and source-hydration targets in `attention.hydrate_first`.
+
+## Safety Model
+
+Sneakoscope intentionally treats these as high-risk:
+
+- SQL and migrations
+- Supabase MCP and RLS changes
+- destructive filesystem operations
+- user-global harness config
+- published package/release state
+
+By default, SKS favors inspection, local files, branch-safe changes, explicit confirmation for destructive DB operations, and completion claims backed by tests or artifacts.
+
+## Troubleshooting
+
+### `sks` points to an old version
+
+```sh
+which sks
+sks --version
+node ./bin/sks.mjs --version
+npm install -g .
+```
+
+If the global command is stale, reinstall globally from the repo or from npm.
+
+### cmux is missing
+
+```sh
+sks deps install cmux
+sks cmux check
+```
+
+`sks --mad` also attempts Homebrew installation or upgrade automatically on macOS when cmux is missing. If Homebrew reports the cask installed but the CLI still is not reachable, SKS checks the cmux app bundle paths directly, wakes the app, and retries the socket before reporting a remaining cmux app/socket issue.
+
+### Codex App tools are missing
+
+```sh
+sks codex-app check
+codex mcp list
+```
+
+Codex App workflows need the app installed and the first-party Browser Use / Computer Use tools available for parity with QA and visual workflows.
+
+### Setup is blocked by another harness
+
+```sh
+sks conflicts check
+sks conflicts prompt
+```
+
+OMX/DCodex conflicts intentionally block setup/doctor until the user approves cleanup.
+
+### The route is stuck or a final hook keeps reopening
+
+```sh
+sks pipeline status --json
+sks team watch latest
+sks wiki validate .sneakoscope/wiki/context-pack.json
+```
+
+Finalization requires real evidence, no unsupported critical claims, valid Team cleanup artifacts, reflection when required, and Honest Mode.
+
+## Development And Release
+
+Run local checks:
+
+```sh
+npm run repo-audit
+npm run changelog:check
+npm run packcheck
+npm run selftest
+npm run sizecheck
+npm run release:check
+```
+
+Dry-run publish:
 
 ```sh
 npm run publish:dry
 ```
 
-This runs repo audit, changelog check, syntax packcheck, mock selftest, sizecheck, and `npm pack --dry-run`. A dry run proves the local package is packable; npm account ownership or OTP can still block the real registry upload.
+`publish:dry` proves the local package is packable. It does not prove npm ownership, OTP, or registry publish permission.
 
-## Requirements
+## Documentation Style
 
-- Node.js `>=20.11`
-- npm
-- Codex CLI/App for app-facing workflows
-- cmux for the CLI-first runtime (`sks deps install cmux`)
-- Context7 MCP for current-docs-gated routes
+This README follows a common open-source CLI shape:
+
+- quick start first
+- explicit install paths
+- separate CLI and app/plugin usage
+- command examples before internal architecture
+- troubleshooting and release checks near the end
+
+That shape mirrors how projects such as `rdme` and Vite separate quick start, setup/configuration, and CLI usage while keeping copy-ready commands visible.
 
 ## License
 

package/package.json

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

package/src/cli/main.mjs

@@ -30,7 +30,7 @@ import { context7Evidence, evaluateStop, recordContext7Evidence, recordSubagentE
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, validateTeamRuntimeArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
 import { appendTeamEvent, formatRoleCounts, initTeamLive, normalizeTeamSpec, parseTeamSpecArgs, parseTeamSpecText, readTeamDashboard, readTeamLive, readTeamTranscriptTail } from '../core/team-live.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
-import { buildCmuxLaunchPlan, defaultCmuxWorkspaceName, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, platformCmuxInstallHint, runCmuxStatus, sanitizeCmuxWorkspaceName, cmuxAvailable } from '../core/cmux-ui.mjs';
+import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, platformCmuxInstallHint, runCmuxStatus, sanitizeCmuxWorkspaceName, cmuxAvailable } from '../core/cmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 
 const flag = (args, name) => args.includes(name);
@@ -116,7 +116,7 @@ Usage:
   sks bootstrap [--install-scope global|project] [--local-only] [--json]
   sks deps check|install [cmux|codex|context7|all] [--yes] [--json]
   sks codex-app
-  sks --mad --high
+  sks --mad [--high]
   sks auto-review status|enable|start [--high]
   sks --Auto-review [--high]
   sks cmux [--workspace name]
@@ -389,13 +389,13 @@ async function ensureCodexCliTool({ skip = false } = {}) {
   const before = await getCodexInfo().catch(() => ({}));
   if (before.bin) return { status: 'present', bin: before.bin, version: before.version || null };
   const npmBin = await which('npm');
-  if (!npmBin) return { status: 'failed', error: 'npm not found on PATH; install Codex CLI manually with npm i -g @openai/codex.' };
-  const install = await runProcess(npmBin, ['i', '-g', '@openai/codex'], {
+  if (!npmBin) return { status: 'failed', error: 'npm not found on PATH; install Codex CLI manually with npm i -g @openai/codex@latest.' };
+  const install = await runProcess(npmBin, ['i', '-g', '@openai/codex@latest'], {
     timeoutMs: 120000,
     maxOutputBytes: 128 * 1024
   }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
   if (install.code !== 0) {
-    return { status: 'failed', error: `${install.stderr || install.stdout || 'npm i -g @openai/codex failed'}`.trim() };
+    return { status: 'failed', error: `${install.stderr || install.stdout || 'npm i -g @openai/codex@latest failed'}`.trim() };
   }
   const after = await getCodexInfo().catch(() => ({}));
   return {
@@ -1044,13 +1044,75 @@ async function cmuxCommand(sub = 'start', args = []) {
 }
 
 async function madHighCommand(args = []) {
-  const cleanArgs = args.filter((arg) => !['--mad', '--MAD', '--mad-sks', '--high'].includes(arg));
+  const cleanArgs = args.filter((arg) => !['--mad', '--MAD', '--mad-sks', '--high', '--no-auto-install-cmux'].includes(arg));
+  if (flag(args, '--json')) {
+    const profile = await enableMadHighProfile();
+    return console.log(JSON.stringify(profile, null, 2));
+  }
+  const update = await maybePromptSksUpdateForMad(args);
+  if (update.status === 'updated') {
+    console.log(`SKS updated from ${PACKAGE_VERSION} to ${update.latest}. Rerun: sks --mad`);
+    return;
+  }
+  if (update.status === 'failed') {
+    console.error(`SKS update failed: ${update.error}`);
+    process.exitCode = 1;
+    return;
+  }
+  const deps = await ensureMadLaunchDependencies(args);
+  if (!deps.ready) {
+    console.error('SKS MAD launch blocked by missing dependencies.');
+    for (const action of deps.actions) printDepsInstallAction(action);
+    process.exitCode = 1;
+    return;
+  }
   const profile = await enableMadHighProfile();
-  if (flag(args, '--json')) return console.log(JSON.stringify(profile, null, 2));
-  console.log(`SKS MAD high profile ready: ${madHighProfileName()}`);
-  console.log('Scope: explicit cmux launch only; normal SKS/DB safety returns after this command.');
+  console.log(`SKS MAD auto-review profile ready: ${madHighProfileName()}`);
+  console.log('Scope: explicit cmux launch only; full access uses Codex auto_review approvals when approval prompts are raised.');
   const workspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', `sks-mad-${defaultCmuxWorkspaceName(process.cwd())}`));
-  return launchCmuxUi([...cleanArgs, '--workspace', workspace], { codexArgs: ['--profile', profile.profile_name] });
+  return launchCmuxUi([...cleanArgs, '--workspace', workspace], {
+    codexArgs: ['--profile', profile.profile_name],
+    autoInstallCmux: !flag(args, '--no-auto-install-cmux'),
+    conciseBlockers: true
+  });
+}
+
+async function maybePromptSksUpdateForMad(args = []) {
+  if (flag(args, '--json') || flag(args, '--skip-update-check') || process.env.SKS_SKIP_UPDATE_CHECK === '1') return { status: 'skipped' };
+  const latest = await npmPackageVersion('sneakoscope');
+  if (!latest.version || compareVersions(latest.version, PACKAGE_VERSION) <= 0) return { status: 'current', latest: latest.version || null, error: latest.error || null };
+  const command = 'npm i -g sneakoscope@latest';
+  if (flag(args, '--yes') || flag(args, '-y')) return installSksLatest(command, latest.version);
+  if (!canAskYesNo()) {
+    console.log(`SKS update available: ${PACKAGE_VERSION} -> ${latest.version}. Run: ${command}`);
+    return { status: 'available', latest: latest.version, command };
+  }
+  const answer = (await askPostinstallQuestion(`SKS ${PACKAGE_VERSION} -> ${latest.version} update before MAD launch? [Y/n] `)).trim();
+  const yes = answer === '' || /^(y|yes|예|네|응)$/i.test(answer);
+  if (!yes) return { status: 'skipped_by_user', latest: latest.version, command };
+  return installSksLatest(command, latest.version);
+}
+
+async function installSksLatest(command, latestVersion) {
+  const npm = await which('npm').catch(() => null);
+  if (!npm) return { status: 'failed', latest: latestVersion, command, error: 'npm not found on PATH' };
+  const install = await runProcess(npm, ['i', '-g', 'sneakoscope@latest'], { timeoutMs: 180000, maxOutputBytes: 128 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  if (install.code !== 0) return { status: 'failed', latest: latestVersion, command, error: `${install.stderr || install.stdout || command + ' failed'}`.trim() };
+  return { status: 'updated', latest: latestVersion, command };
+}
+
+async function ensureMadLaunchDependencies(args = []) {
+  const actions = [];
+  if (!flag(args, '--skip-cli-tools')) {
+    const codex = await getCodexInfo().catch(() => ({}));
+    if (!codex.bin) actions.push(await installCodexDependency(args, { prompt: 'Codex CLI missing. Install latest Codex CLI with npm i -g @openai/codex@latest?' }));
+  }
+  if (!flag(args, '--no-auto-install-cmux')) {
+    const cmux = await cmuxAvailable().catch(() => ({ ok: false }));
+    if (!cmux.ok && !cmux.bin) actions.push(await installCmuxDependency(args));
+  }
+  const status = await depsStatus(await projectRoot());
+  return { ready: Boolean(status.codex_cli.ok && (status.cmux.ok || status.cmux.bin)), actions, status };
 }
 
 async function deps(sub = 'check', args = []) {
@@ -1094,7 +1156,7 @@ async function depsStatus(root = null, opts = {}) {
     context7,
     browser_use: { ok: app.mcp.has_browser_use, cache: app.plugins.browser_use_cache },
     computer_use: { ok: app.mcp.has_computer_use, cache: app.plugins.computer_use_cache },
-    cmux: { ok: Boolean(cmux.ok), version: cmux.version || null, install_hint: cmux.ok ? null : platformCmuxInstallHint(), error: cmux.error || null },
+    cmux: { ok: Boolean(cmux.ok), bin: cmux.bin || null, version: cmux.version || null, install_hint: cmux.ok ? null : platformCmuxInstallHint(), error: cmux.error || null },
     homebrew: process.platform === 'darwin' ? { ok: Boolean(brew), bin: brew, required_for_cmux_install: homebrewNeeded } : { ok: null, bin: null, required_for_cmux_install: false },
     next_actions: depsNextActions({ npmBin, globalBin, codex, app, context7, cmux, brew, nodeOk })
   };
@@ -1149,10 +1211,11 @@ async function depsInstall(args = []) {
   if (!status.ready) process.exitCode = 1;
 }
 
-async function installCodexDependency(args = []) {
+async function installCodexDependency(args = [], opts = {}) {
   const before = await getCodexInfo().catch(() => ({}));
   if (before.bin) return { target: 'codex', status: 'present', bin: before.bin, version: before.version || null };
-  if (!await confirmInstall('Install Codex CLI with npm i -g @openai/codex?', args)) return { target: 'codex', status: 'needs_approval', command: 'npm i -g @openai/codex' };
+  const command = 'npm i -g @openai/codex@latest';
+  if (!await confirmInstall(opts.prompt || `Install Codex CLI with ${command}?`, args)) return { target: 'codex', status: 'needs_approval', command };
   return { target: 'codex', ...(await ensureCodexCliTool()) };
 }
 
@@ -1168,25 +1231,33 @@ async function installCmuxDependency(args = []) {
   if (before.ok) return { target: 'cmux', status: 'present', version: before.version || null };
   if (process.platform === 'darwin') {
     const brew = await which('brew').catch(() => null);
-    const command = 'brew tap manaflow-ai/cmux && brew install --cask cmux';
+    const command = CMUX_BREW_COMMAND;
     if (!brew) return { target: 'cmux', status: 'homebrew_missing', command: `/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" && ${command}` };
     if (flag(args, '--dry-run')) return { target: 'cmux', status: 'dry_run', command };
-    if (!await confirmInstall(`Install cmux with Homebrew (${command})?`, args)) return { target: 'cmux', status: 'needs_approval', command };
-    const tap = await runProcess(brew, ['tap', 'manaflow-ai/cmux'], { timeoutMs: 180000, maxOutputBytes: 128 * 1024 });
-    const run = tap.code === 0
-      ? await runProcess(brew, ['install', '--cask', 'cmux'], { timeoutMs: 180000, maxOutputBytes: 128 * 1024 })
-      : tap;
-    return { target: 'cmux', status: run.code === 0 ? 'installed' : 'failed', command, code: run.code, error: run.code === 0 ? null : `${run.stderr || run.stdout || 'brew install --cask cmux failed'}`.trim() };
+    if (!await confirmInstall(`Install/update latest cmux with Homebrew (${command}; ${CMUX_BREW_UPGRADE_COMMAND} if already installed)?`, args)) return { target: 'cmux', status: 'needs_approval', command };
+    const installed = await ensureCmuxInstalled({ autoInstall: true });
+    return {
+      target: 'cmux',
+      status: installed.status,
+      version: installed.cmux?.version || null,
+      command,
+      code: installed.code,
+      error: installed.error || null
+    };
   }
   return { target: 'cmux', status: 'manual_required', command: platformCmuxInstallHint() };
 }
 
 async function confirmInstall(question, args = []) {
   if (flag(args, '--yes') || flag(args, '-y')) return true;
-  if (!input.isTTY || !output.isTTY || process.env.CI === 'true') return false;
+  if (!canAskYesNo()) return false;
   return /^(y|yes|예|네|응)$/i.test((await askPostinstallQuestion(`${question} [y/N] `)).trim());
 }
 
+function canAskYesNo() {
+  return Boolean(input.isTTY && output.isTTY && process.env.CI !== 'true');
+}
+
 function printDepsInstallAction(action) {
   if (!action) return;
   console.log(`${action.target}: ${action.status}${action.version ? ` ${action.version}` : ''}`);
@@ -1759,6 +1830,8 @@ async function npmGlobalSksBin() {
 }
 
 async function npmPackageVersion(name) {
+  const envName = `SKS_NPM_VIEW_${String(name || '').replace(/[^A-Za-z0-9]+/g, '_').toUpperCase()}_VERSION`;
+  if (process.env[envName]) return { version: process.env[envName] };
   const npm = await which('npm').catch(() => null);
   if (!npm) return { error: 'npm not found' };
   const result = await runProcess(npm, ['view', name, 'version'], { timeoutMs: 5000, maxOutputBytes: 4096 });
@@ -2251,7 +2324,7 @@ async function selftest() {
   const madProfilePath = path.join(tmp, 'mad-codex-config.toml');
   const madProfile = await enableMadHighProfile({ configPath: madProfilePath });
   const madProfileText = await safeReadText(madProfilePath);
-  if (madProfile.profile_name !== 'sks-mad-high' || !madProfileText.includes('sandbox_mode = "danger-full-access"') || !madProfileText.includes('approval_policy = "never"') || !madProfileText.includes('model_reasoning_effort = "high"')) throw new Error('selftest failed: MAD high profile is not full-access high/fast');
+  if (madProfile.profile_name !== 'sks-mad-high' || !madProfileText.includes('sandbox_mode = "danger-full-access"') || !madProfileText.includes('approval_policy = "on-request"') || !madProfileText.includes('approvals_reviewer = "auto_review"') || !madProfileText.includes('model_reasoning_effort = "high"')) throw new Error('selftest failed: MAD high profile is not full-access auto-review high');
   if (!isMadHighLaunch(['--mad', '--high']) || isMadHighLaunch(['db', '--mad'])) throw new Error('selftest failed: MAD high launch flag parsing is not top-level only');
   const guardBlocked = await checkHarnessModification(tmp, { tool_name: 'apply_patch', command: '*** Update File: .agents/skills/team/SKILL.md\n+tamper\n' });
   if (guardBlocked.action !== 'block') throw new Error('selftest failed: harness guard allowed skill tampering');
@@ -2646,11 +2719,11 @@ async function selftest() {
   const autoReviewEnabled = await enableAutoReview({ env: autoReviewEnv, high: true });
   if (!autoReviewEnabled.enabled || autoReviewEnabled.profile_name !== 'sks-auto-review-high' || !autoReviewEnabled.high_profile) throw new Error('selftest failed: auto-review high profile was not enabled');
   const autoReviewConfig = await safeReadText(path.join(autoReviewHome, '.codex', 'config.toml'));
-  if (!autoReviewConfig.includes('approvals_reviewer = "guardian_subagent"') || autoReviewConfig.includes('approvals_reviewer = "auto_review"') || !autoReviewConfig.includes('[profiles.sks-auto-review-high]')) throw new Error('selftest failed: auto-review config not written');
+  if (!autoReviewConfig.includes('approvals_reviewer = "auto_review"') || autoReviewConfig.includes('approvals_reviewer = "guardian_subagent"') || !autoReviewConfig.includes('[profiles.sks-auto-review-high]')) throw new Error('selftest failed: auto-review config not written');
   const autoReviewDisabled = await disableAutoReview({ env: autoReviewEnv });
   if (autoReviewDisabled.enabled || autoReviewDisabled.approvals_reviewer !== 'user') throw new Error('selftest failed: auto-review disable did not restore user reviewer');
   const autoReviewDisabledConfig = await safeReadText(path.join(autoReviewHome, '.codex', 'config.toml'));
-  if (autoReviewDisabledConfig.includes('approvals_reviewer = "auto_review"')) throw new Error('selftest failed: auto-review disable left legacy invalid reviewer values');
+  if (autoReviewDisabledConfig.includes('approvals_reviewer = "guardian_subagent"')) throw new Error('selftest failed: auto-review disable left legacy reviewer values');
   const analysisAgentExists = await exists(path.join(tmp, '.codex', 'agents', 'analysis-scout.toml'));
   if (!analysisAgentExists) throw new Error('selftest failed: analysis scout agent not installed');
   const teamAgentExists = await exists(path.join(tmp, '.codex', 'agents', 'team-consensus.toml'));

package/src/core/auto-review.mjs

@@ -2,8 +2,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { ensureDir, exists, readText, writeTextAtomic } from './fsx.mjs';
 
-export const AUTO_REVIEW_REVIEWER = 'guardian_subagent';
-export const LEGACY_AUTO_REVIEW_REVIEWER = 'auto_review';
+export const AUTO_REVIEW_REVIEWER = 'auto_review';
+export const LEGACY_AUTO_REVIEW_REVIEWER = 'guardian_subagent';
 export const AUTO_REVIEW_PROFILE = 'sks-auto-review';
 export const AUTO_REVIEW_HIGH_PROFILE = 'sks-auto-review-high';
 export const MAD_HIGH_PROFILE = 'sks-mad-high';
@@ -64,10 +64,12 @@ export async function enableMadHighProfile(opts = {}) {
   let next = upsertTable(current, `profiles.${MAD_HIGH_PROFILE}`, [
     `[profiles.${MAD_HIGH_PROFILE}]`,
     'model = "gpt-5.5"',
-    'approval_policy = "never"',
+    'approval_policy = "on-request"',
+    `approvals_reviewer = "${AUTO_REVIEW_REVIEWER}"`,
     'sandbox_mode = "danger-full-access"',
     'model_reasoning_effort = "high"'
   ].join('\n'));
+  next = upsertAutoReviewPolicy(next);
   if (!next.endsWith('\n')) next += '\n';
   await writeTextAtomic(configPath, next);
   return {
@@ -75,7 +77,8 @@ export async function enableMadHighProfile(opts = {}) {
     profile_name: MAD_HIGH_PROFILE,
     launch_args: ['--profile', MAD_HIGH_PROFILE],
     sandbox_mode: 'danger-full-access',
-    approval_policy: 'never',
+    approval_policy: 'on-request',
+    approvals_reviewer: AUTO_REVIEW_REVIEWER,
     model_reasoning_effort: 'high',
     scope: 'explicit_launch_only'
   };
@@ -111,7 +114,7 @@ export function autoReviewSummary(status = {}) {
     lines.push('Launch high mode with: sks --Auto-review --high');
   }
   if (status.legacy_invalid) {
-    lines.push('', 'Legacy invalid reviewer value found: run sks auto-review enable or sks auto-review disable to rewrite Codex config.');
+    lines.push('', 'Legacy reviewer value found: run sks auto-review enable or sks auto-review disable to rewrite Codex config.');
   }
   return lines.join('\n');
 }

package/src/core/cmux-ui.mjs

@@ -1,16 +1,22 @@
 import path from 'node:path';
+import fsp from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
 import { exists, packageRoot, projectRoot, runProcess, sha256, which } from './fsx.mjs';
 import { getCodexInfo } from './codex-adapter.mjs';
 import { codexAppIntegrationStatus, formatCodexAppStatus } from './codex-app.mjs';
 
 export const SKS_CMUX_LOGO = [
-  '+----------------------+',
-  '|        ㅅㅋㅅ         |',
-  '|       SKS cmux       |',
-  '+----------------------+'
+  '   _____ __ __ _____',
+  '  / ___// //_// ___/',
+  '  \\__ \\/ ,<   \\__ \\   ㅅㅋㅅ',
+  ' ___/ / /| | ___/ /',
+  '/____/_/ |_|/____/',
+  'Sneakoscope Codex cmux'
 ].join('\n');
 
+export const CMUX_BREW_COMMAND = 'brew tap manaflow-ai/cmux && brew install --cask cmux';
+export const CMUX_BREW_UPGRADE_COMMAND = 'brew tap manaflow-ai/cmux && brew upgrade --cask cmux';
+
 export function sanitizeCmuxWorkspaceName(input) {
   const base = String(input || 'sks').trim().replace(/[^A-Za-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
   return (base || 'sks').slice(0, 80);
@@ -29,9 +35,9 @@ export function shellEscape(value) {
 export function platformCmuxInstallHint() {
   if (process.platform !== 'darwin') return 'cmux is a native macOS app; install it on macOS 14+ from https://cmux.com or https://github.com/manaflow-ai/cmux.';
   return [
-    'brew tap manaflow-ai/cmux && brew install --cask cmux',
-    'then expose the CLI if needed:',
-    'sudo ln -sf "/Applications/cmux.app/Contents/Resources/bin/cmux" /usr/local/bin/cmux'
+    CMUX_BREW_COMMAND,
+    'then run:',
+    'sks cmux check'
   ].join(' ');
 }
 
@@ -40,17 +46,78 @@ export async function findCmuxBinary() {
   if (env && await exists(env)) return env;
   const onPath = await which('cmux').catch(() => null);
   if (onPath) return onPath;
-  const appBin = '/Applications/cmux.app/Contents/Resources/bin/cmux';
-  if (process.platform === 'darwin' && await exists(appBin)) return appBin;
+  for (const candidate of cmuxBinaryCandidates()) {
+    if (await exists(candidate)) return candidate;
+  }
   return null;
 }
 
+export function cmuxBinaryCandidates() {
+  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);
+  const candidates = [];
+  for (const app of appBundles) {
+    candidates.push(
+      path.join(app, 'Contents', 'Resources', 'bin', 'cmux'),
+      path.join(app, 'Contents', 'MacOS', 'cmux')
+    );
+  }
+  candidates.push('/opt/homebrew/bin/cmux', '/usr/local/bin/cmux');
+  return Array.from(new Set(candidates));
+}
+
 export async function cmuxAvailable() {
   const bin = await findCmuxBinary();
   if (!bin) return { ok: false, bin: null, version: null, error: 'cmux CLI not found' };
-  const probe = await runProcess(bin, ['list-workspaces', '--json'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
+  const probe = await runProcess(bin, ['version'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
   const text = `${probe.stdout || ''}${probe.stderr || ''}`.trim();
-  return { ok: probe.code === 0, bin, version: text || 'cmux CLI', error: probe.code === 0 ? null : text || 'cmux workspace probe failed' };
+  return { ok: probe.code === 0, bin, version: text || 'cmux CLI', error: probe.code === 0 ? null : text || 'cmux CLI probe failed' };
+}
+
+export async function ensureCmuxInstalled(opts = {}) {
+  const before = await cmuxAvailable().catch((err) => ({ ok: false, error: err.message || 'cmux probe failed' }));
+  if (before.ok) return { target: 'cmux', status: 'present', cmux: before, command: null };
+  if (opts.autoInstall === false || process.env.SKS_NO_CMUX_AUTO_INSTALL === '1') {
+    return { target: 'cmux', status: 'missing', cmux: before, command: CMUX_BREW_COMMAND, error: before.error || 'cmux CLI not found' };
+  }
+  if (process.platform !== 'darwin') {
+    return { target: 'cmux', status: 'manual_required', cmux: before, command: platformCmuxInstallHint(), error: before.error || 'cmux is macOS-only' };
+  }
+  const brew = await which('brew').catch(() => null);
+  if (!brew) {
+    return { target: 'cmux', status: 'homebrew_missing', cmux: before, command: CMUX_BREW_COMMAND, error: 'Homebrew is required for automatic cmux install' };
+  }
+  if (!opts.quiet) console.log('cmux CLI missing; installing/updating cmux with Homebrew...');
+  const tap = await runProcess(brew, ['tap', 'manaflow-ai/cmux'], { timeoutMs: 180000, maxOutputBytes: 128 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  const install = tap.code === 0
+    ? await installOrUpgradeCmuxCask(brew)
+    : tap;
+  let after = await cmuxAvailable().catch((err) => ({ ok: false, error: err.message || 'cmux probe failed after install' }));
+  if (!after.ok && after.bin) after = await wakeCmuxAndReprobe(after);
+  if (after.ok) return { target: 'cmux', status: 'installed', cmux: after, command: CMUX_BREW_COMMAND };
+  const installText = `${install.stderr || ''}\n${install.stdout || ''}`.trim();
+  const rawError = after.error || installText || 'brew install --cask cmux completed, but no working cmux CLI was found';
+  return { target: 'cmux', status: 'failed', cmux: after, command: CMUX_BREW_COMMAND, code: install.code, error: rawError };
+}
+
+async function installOrUpgradeCmuxCask(brew) {
+  const install = await runProcess(brew, ['install', '--cask', 'cmux'], { timeoutMs: 300000, maxOutputBytes: 256 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  if (install.code === 0) return install;
+  const text = `${install.stderr || ''}\n${install.stdout || ''}`;
+  if (!/already installed|to upgrade|brew upgrade/i.test(text)) return install;
+  const upgrade = await runProcess(brew, ['upgrade', '--cask', 'cmux'], { timeoutMs: 300000, maxOutputBytes: 256 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  return upgrade.code === 0 ? upgrade : install;
 }
 
 export function codexLaunchCommand(root, codexBin, codexArgs = []) {
@@ -110,7 +177,7 @@ export function formatCmuxBanner(status = null) {
     '',
     'CLI-first runtime:',
     '  sks                 open a cmux Codex CLI workspace',
-    '  sks --mad --high    open one-shot MAD-SKS high reasoning workspace',
+    '  sks --mad           open one-shot MAD full-access auto-review workspace',
     '  sks team "task"     prepare Team mission and cmux multi-line agent view',
     '',
     'Useful terminal commands:',
@@ -126,15 +193,29 @@ export function formatCmuxBanner(status = null) {
 export async function launchCmuxUi(args = [], opts = {}) {
   const rootArg = readOption(args, '--root', opts.root);
   const workspaceArg = readOption(args, '--workspace', readOption(args, '--session', opts.workspace || opts.session));
-  const plan = await buildCmuxLaunchPlan({ ...opts, root: rootArg, workspace: workspaceArg });
+  let plan = await buildCmuxLaunchPlan({ ...opts, root: rootArg, workspace: workspaceArg });
+  let cmuxRepair = null;
+  if (!plan.ready && plan.cmux.bin && !plan.cmux.ok && !args.includes('--json')) {
+    const warmed = await wakeCmuxAndReprobe(plan.cmux);
+    if (warmed.ok) plan = await buildCmuxLaunchPlan({ ...opts, root: rootArg, workspace: workspaceArg, cmux: warmed });
+  }
+  if (!plan.ready && !plan.cmux.ok && opts.autoInstallCmux && !args.includes('--json')) {
+    cmuxRepair = await ensureCmuxInstalled({ autoInstall: true, quiet: Boolean(opts.quietAutoInstall || args.includes('--quiet')) });
+    if (cmuxRepair.cmux?.ok) plan = await buildCmuxLaunchPlan({ ...opts, root: rootArg, workspace: workspaceArg, cmux: cmuxRepair.cmux });
+  }
   if (args.includes('--json')) return { plan };
   if (!plan.ready && !args.includes('--status-only')) {
-    console.log(formatCmuxBanner(plan.app));
-    console.log('\nLaunch blocked:\n');
-    for (const blocker of Array.from(new Set(plan.blockers))) console.log(`- ${blocker}`);
+    printCmuxLaunchBlocked(plan, { concise: opts.conciseBlockers, cmuxRepair });
     process.exitCode = 1;
     return { plan };
   }
+  const daemon = await ensureCmuxDaemonReady(plan.cmux);
+  if (!daemon.ok && !args.includes('--status-only')) {
+    const blocked = { ...plan, ready: false, cmux: { ...plan.cmux, ok: false, error: daemon.error || 'cmux app did not become ready' } };
+    printCmuxLaunchBlocked(blocked, { concise: opts.conciseBlockers, cmuxRepair });
+    process.exitCode = 1;
+    return { plan: blocked };
+  }
   if (!args.includes('--no-open')) await openCmuxApp().catch(() => null);
   const command = codexLaunchCommand(plan.root, plan.codex.bin, plan.codexArgs);
   const created = spawnSync(plan.cmux.bin, ['new-workspace', '--cwd', plan.root, '--command', command], { encoding: 'utf8', stdio: args.includes('--quiet') ? 'pipe' : 'inherit' });
@@ -149,10 +230,94 @@ export async function launchCmuxUi(args = [], opts = {}) {
   return { plan, created: true };
 }
 
+function printCmuxLaunchBlocked(plan, opts = {}) {
+  if (opts.concise) {
+    console.error('SKS cmux launch blocked.');
+    if (!plan.cmux.ok) {
+      const repair = opts.cmuxRepair;
+      const installedButUnhealthy = Boolean(plan.cmux.bin);
+      const prefix = repair?.status
+        ? `cmux ${repair.status}`
+        : installedButUnhealthy
+          ? 'cmux app/socket unhealthy'
+          : 'cmux missing';
+      console.error(`- ${prefix}: ${repair?.error || plan.cmux.error || 'cmux CLI not found'}`);
+      console.error(`- ${installedButUnhealthy ? 'Repair command' : 'Install command'}: ${repair?.command || (installedButUnhealthy ? 'sks deps install cmux --yes' : CMUX_BREW_COMMAND)}`);
+    }
+    if (!plan.codex.bin) console.error('- Codex CLI missing. Install: npm i -g @openai/codex@latest, or set SKS_CODEX_BIN.');
+    return;
+  }
+  console.log(formatCmuxBanner(plan.app));
+  console.log('\nLaunch blocked:\n');
+  for (const blocker of Array.from(new Set(plan.blockers))) console.log(`- ${blocker}`);
+}
+
 export async function openCmuxApp() {
   if (process.platform !== 'darwin') return { ok: false, reason: 'not_macos' };
   const run = await runProcess('open', ['-a', 'cmux'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
-  return { ok: run.code === 0, stdout: run.stdout || '', stderr: run.stderr || '' };
+  if (run.code === 0) return { ok: true, stdout: run.stdout || '', stderr: run.stderr || '' };
+  for (const app of ['/Applications/cmux.app', '/Applications/Cmux.app']) {
+    if (!await exists(app)) continue;
+    const byPath = await runProcess('open', [app], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
+    if (byPath.code === 0) return { ok: true, stdout: byPath.stdout || '', stderr: byPath.stderr || '' };
+  }
+  return { ok: false, stdout: run.stdout || '', stderr: run.stderr || '' };
+}
+
+async function wakeCmuxAndReprobe(fallback = {}) {
+  return ensureCmuxDaemonReady(fallback);
+}
+
+async function ensureCmuxDaemonReady(cmux = {}) {
+  if (!cmux?.bin) return { ok: false, error: cmux?.error || 'cmux CLI not found' };
+  const first = await cmuxSocketProbe(cmux.bin);
+  if (first.ok) return { ...cmux, ok: true, error: null };
+  if (process.platform !== 'darwin') return first;
+  const opened = await openCmuxApp().catch(() => null);
+  if (!opened?.ok) return { ok: false, error: opened?.stderr || opened?.reason || first.error || 'cmux app launch failed' };
+  let last = first;
+  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 };
+  }
+  if (isRecoverableCmuxSocketError(last.error) && process.env.SKS_CMUX_NO_RESTART !== '1') {
+    await restartCmuxApp();
+    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 };
+    }
+  }
+  return { ok: false, error: last.error || 'cmux socket did not become ready' };
+}
+
+async function cmuxSocketProbe(bin) {
+  const probe = await runProcess(bin, ['list-workspaces', '--json'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
+  const text = `${probe.stdout || ''}${probe.stderr || ''}`.trim();
+  return { ok: probe.code === 0, error: probe.code === 0 ? null : text || 'cmux socket probe failed' };
+}
+
+function isRecoverableCmuxSocketError(error) {
+  return /socket|broken pipe|receive timeout|connection refused/i.test(String(error || ''));
+}
+
+async function restartCmuxApp() {
+  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) {
+    await runProcess('pkill', ['-TERM', '-f', '/Applications/cmux.app/Contents/MacOS/cmux'], { timeoutMs: 8000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+  }
+  await new Promise((resolve) => setTimeout(resolve, 1500));
+  await removeStaleCmuxSocket().catch(() => null);
+  return openCmuxApp();
+}
+
+async function removeStaleCmuxSocket() {
+  const home = process.env.HOME;
+  if (!home) return;
+  const sock = path.join(home, 'Library', 'Application Support', 'cmux', 'cmux.sock');
+  await fsp.rm(sock, { force: true });
 }
 
 export async function launchCmuxTeamView({ root, missionId, plan = {}, promptFile = null, json = false } = {}) {

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

package/src/core/init.mjs

@@ -404,10 +404,14 @@ export async function initProject(root, opts = {}) {
 
   await writeTextAtomic(path.join(root, '.codex', 'config.toml'), `[features]\ncodex_hooks = true\nmulti_agent = true\n\n[agents]\nmax_threads = 6\nmax_depth = 1\n\n${context7ConfigToml()}\n[agents.analysis_scout]\ndescription = "Read-only SKS scout."\nconfig_file = "./agents/analysis-scout.toml"\nnickname_candidates = ["Scout", "Mapper"]\n\n[agents.team_consensus]\ndescription = "SKS planning/debate agent."\nconfig_file = "./agents/team-consensus.toml"\nnickname_candidates = ["Consensus", "Atlas"]\n\n[agents.implementation_worker]\ndescription = "SKS bounded implementation worker."\nconfig_file = "./agents/implementation-worker.toml"\nnickname_candidates = ["Builder", "Mason"]\n\n[agents.db_safety_reviewer]\ndescription = "Read-only DB safety reviewer."\nconfig_file = "./agents/db-safety-reviewer.toml"\nnickname_candidates = ["Sentinel", "Ledger"]\n\n[agents.qa_reviewer]\ndescription = "Read-only QA reviewer."\nconfig_file = "./agents/qa-reviewer.toml"\nnickname_candidates = ["Verifier", "Scout"]\n\n[profiles.sks-task-medium]\nmodel = "gpt-5.5"\napproval_policy = "on-request"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "medium"\n\n[profiles.sks-logic-high]\nmodel = "gpt-5.5"\napproval_policy = "on-request"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "high"\n\n[profiles.sks-research-xhigh]\nmodel = "gpt-5.5"\napproval_policy = "on-request"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "xhigh"\n\n[profiles.sks-ralph]\nmodel = "gpt-5.5"\napproval_policy = "never"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "high"\n\n[profiles.sks-research]\nmodel = "gpt-5.5"\napproval_policy = "never"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "xhigh"\n\n[profiles.sks-team]\nmodel = "gpt-5.5"\napproval_policy = "on-request"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "high"\n\n[profiles.sks-mad-high]
 model = "gpt-5.5"
-approval_policy = "never"
+approval_policy = "on-request"
+approvals_reviewer = "auto_review"
 sandbox_mode = "danger-full-access"
 model_reasoning_effort = "high"
 
+[auto_review]
+policy = "Deny destructive database operations, credential exfiltration, persistent security weakening, broad file deletion, and writes outside the workspace unless explicitly authorized by the user."
+
 [profiles.sks-default]\nmodel = "gpt-5.5"\napproval_policy = "on-request"\nsandbox_mode = "workspace-write"\nmodel_reasoning_effort = "medium"\n`);
   created.push('.codex/config.toml');
 

package/src/core/routes.mjs

@@ -334,7 +334,7 @@ export const COMMAND_CATALOG = [
   { name: 'deps', usage: 'sks deps check|install [cmux|codex|context7|all] [--yes]', description: 'Check or guided-install Node/npm PATH, Codex CLI/App, Context7, Browser Use, Computer Use, cmux, and Homebrew on macOS.' },
   { name: 'codex-app', usage: 'sks codex-app [check|open]', description: 'Check Codex App install and first-party MCP/plugin readiness, then show app setup files and examples.' },
   { name: 'cmux', usage: 'sks cmux [check|status] [--workspace name]', description: 'Open the SKS cmux runtime with the ㅅㅋㅅ ASCII status pane and Codex CLI.' },
-  { name: 'mad-high', usage: 'sks --mad --high', description: 'Open a one-shot cmux Codex CLI workspace with the SKS MAD high full-access profile.' },
+  { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot cmux Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
   { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS cmux with the auto-review profile.' },
   { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
   { name: 'dfix', usage: 'sks dfix', description: 'Explain $DFix ultralight design/content fix mode.' },