sneakoscope 2.0.1 → 2.0.4

package/dist/core/codex-control/gpt-final-proof-pack.js

@@ -0,0 +1,120 @@
+import { nowIso, sha256 } from '../fsx.js';
+export const GPT_FINAL_PROOF_PACK_SCHEMA = 'sks.gpt-final-proof-pack.v1';
+export function buildGptFinalProofPack(input, opts = {}) {
+    const maxCriticalLogChars = Math.max(1000, Number(opts.maxCriticalLogChars || 6000));
+    const localOutputs = Array.isArray(input.local_outputs) ? input.local_outputs : [];
+    const candidatePatchEnvelopes = Array.isArray(input.candidate_patch_envelopes) ? input.candidate_patch_envelopes : [];
+    const verificationResults = Array.isArray(input.verification_results) ? input.verification_results : [];
+    const pack = {
+        schema: GPT_FINAL_PROOF_PACK_SCHEMA,
+        generated_at: nowIso(),
+        route: String(input.route || ''),
+        mission_id: String(input.mission_id || ''),
+        local_mode: String(input.local_mode || ''),
+        worker_count: localOutputs.length,
+        changed_files: sortedUnique([
+            ...candidatePatchEnvelopes.flatMap((envelope) => envelopeChangedFiles(envelope)),
+            ...localOutputs.flatMap((output) => Array.isArray(output?.changed_files) ? output.changed_files.map(String) : [])
+        ]),
+        local_output_summaries: localOutputs.map((output, index) => ({
+            worker_id: String(output?.worker_id || output?.agent_id || output?.id || `worker-${index + 1}`),
+            backend: String(output?.backend || 'local-llm'),
+            status: String(output?.status || 'unknown'),
+            summary: trim(String(output?.summary || ''), 600),
+            proof: trim(String(output?.proof || output?.verification?.status || ''), 600),
+            blocker_count: Array.isArray(output?.blockers) ? output.blockers.length : 0,
+            patch_envelope_count: Array.isArray(output?.patch_envelopes) ? output.patch_envelopes.length : output?.patch_envelope ? 1 : 0
+        })),
+        candidate_diff_sha256: sha256(String(input.candidate_diff || '')),
+        candidate_diff_tail: tail(String(input.candidate_diff || ''), maxCriticalLogChars),
+        candidate_patch_envelopes: candidatePatchEnvelopes.map((envelope, index) => summarizeEnvelope(envelope, index)),
+        verification_failures: verificationResults.filter((result) => result?.ok === false || result?.status === 'failed').map((result) => ({
+            id: String(result?.id || result?.patch_entry_id || result?.name || 'verification'),
+            status: String(result?.status || (result?.ok === false ? 'failed' : 'unknown')),
+            blockers: stringArray(result?.blockers || result?.violations)
+        })),
+        side_effect_ledger_summary: summarizeObject(input.side_effect_report),
+        mutation_ledger_summary: summarizeObject(input.mutation_ledger),
+        rollback_plan_summary: summarizeObject(input.rollback_plan),
+        conflict_map: buildConflictMap(candidatePatchEnvelopes),
+        critical_logs_tail: tail(JSON.stringify({
+            local_outputs: localOutputs.map((output) => ({
+                id: output?.worker_id || output?.agent_id || output?.id,
+                blockers: output?.blockers || [],
+                unverified: output?.unverified || []
+            })),
+            verification_results: verificationResults
+        }), maxCriticalLogChars),
+        token_budget_estimate: 0
+    };
+    return {
+        ...pack,
+        token_budget_estimate: estimateTokens(pack)
+    };
+}
+export function buildGptFinalLatencyBudgetReport(input) {
+    const workerCount = Math.max(0, Number(input.workerCount || 0));
+    const tokenBudgetEstimate = Math.max(0, Number(input.tokenBudgetEstimate || 0));
+    const capAdjustment = tokenBudgetEstimate > 8000 || workerCount > 20 ? 'reduce_local_parallelism_or_pack_size' : 'within_budget';
+    return {
+        schema: 'sks.gpt-final-latency-budget.v1',
+        generated_at: nowIso(),
+        worker_count: workerCount,
+        token_budget_estimate: tokenBudgetEstimate,
+        latency_ms: input.latencyMs ?? null,
+        cap_adjustment: capAdjustment,
+        ok: capAdjustment === 'within_budget'
+    };
+}
+function summarizeEnvelope(envelope, index) {
+    return {
+        id: String(envelope?.id || envelope?.patch_id || `patch-${index + 1}`),
+        agent_id: String(envelope?.agent_id || 'unknown'),
+        source: String(envelope?.source || 'local-llm'),
+        operations: Array.isArray(envelope?.operations) ? envelope.operations.length : 0,
+        write_paths: envelopeChangedFiles(envelope),
+        lease_id: envelope?.lease_id || envelope?.lease_proof?.lease_id || null,
+        rollback_ready: Boolean(envelope?.rollback_hint || envelope?.lease_proof?.rollback_node_id)
+    };
+}
+function envelopeChangedFiles(envelope) {
+    return Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => String(operation?.path || '')).filter(Boolean) : [];
+}
+function buildConflictMap(envelopes) {
+    const owners = new Map();
+    for (const envelope of envelopes) {
+        const agent = String(envelope?.agent_id || 'unknown');
+        for (const file of envelopeChangedFiles(envelope))
+            owners.set(file, [...(owners.get(file) || []), agent]);
+    }
+    return [...owners.entries()]
+        .filter(([, agents]) => new Set(agents).size > 1)
+        .map(([file, agents]) => ({ file, agents: sortedUnique(agents) }));
+}
+function summarizeObject(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    return {
+        schema: value.schema || null,
+        ok: typeof value.ok === 'boolean' ? value.ok : null,
+        status: value.status || null,
+        blockers: stringArray(value.blockers).slice(0, 20),
+        keys: Object.keys(value).slice(0, 30)
+    };
+}
+function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+function tail(value, max) {
+    return value.length <= max ? value : value.slice(value.length - max);
+}
+function trim(value, max) {
+    return value.length <= max ? value : value.slice(0, max);
+}
+function sortedUnique(values) {
+    return [...new Set(values.map(String).filter(Boolean))].sort();
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+//# sourceMappingURL=gpt-final-proof-pack.js.map

package/dist/core/codex-control/gpt-final-review-schema.js

@@ -0,0 +1,71 @@
+export const GPT_FINAL_ARBITER_RESULT_SCHEMA_ID = 'sks.gpt-final-arbiter-result.v1';
+export const GPT_FINAL_ARBITER_INPUT_SCHEMA = 'sks.gpt-final-arbiter-input.v1';
+export const gptFinalArbiterResultSchema = {
+    type: 'object',
+    required: [
+        'schema',
+        'status',
+        'summary',
+        'gpt_review_findings',
+        'accepted_patch_envelopes',
+        'modified_patch_envelopes',
+        'rejected_patch_envelopes',
+        'required_followup_work',
+        'verification_plan',
+        'rollback_notes',
+        'blockers',
+        'confidence'
+    ],
+    properties: {
+        schema: { const: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID },
+        status: { enum: ['approved', 'modified', 'rejected', 'needs_more_work'] },
+        summary: { type: 'string' },
+        gpt_review_findings: { type: 'array', items: { type: 'object' } },
+        accepted_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        modified_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        rejected_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        required_followup_work: { type: 'array', items: { type: 'object' } },
+        verification_plan: { type: 'array', items: { type: 'string' } },
+        rollback_notes: { type: 'array', items: { type: 'string' } },
+        blockers: { type: 'array', items: { type: 'string' } },
+        confidence: { enum: ['low', 'medium', 'high'] }
+    },
+    additionalProperties: true
+};
+export function normalizeGptFinalArbiterResult(value) {
+    const status = normalizeStatus(value?.status);
+    return {
+        schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+        status,
+        summary: String(value?.summary || defaultSummary(status)),
+        gpt_review_findings: array(value?.gpt_review_findings),
+        accepted_patch_envelopes: array(value?.accepted_patch_envelopes),
+        modified_patch_envelopes: array(value?.modified_patch_envelopes),
+        rejected_patch_envelopes: array(value?.rejected_patch_envelopes),
+        required_followup_work: array(value?.required_followup_work),
+        verification_plan: stringArray(value?.verification_plan),
+        rollback_notes: stringArray(value?.rollback_notes),
+        blockers: stringArray(value?.blockers),
+        confidence: normalizeConfidence(value?.confidence)
+    };
+}
+function normalizeStatus(value) {
+    return value === 'approved' || value === 'modified' || value === 'rejected' || value === 'needs_more_work'
+        ? value
+        : 'needs_more_work';
+}
+function normalizeConfidence(value) {
+    return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+function defaultSummary(status) {
+    return status === 'approved' || status === 'modified'
+        ? 'GPT final arbiter accepted the candidate result.'
+        : 'GPT final arbiter did not approve the candidate result.';
+}
+//# sourceMappingURL=gpt-final-review-schema.js.map

package/dist/core/commands/basic-cli.js

@@ -10,7 +10,7 @@ import { buildFeatureRegistry, validateFeatureRegistry } from '../feature-regist
 import { hooksExplainReport } from '../../cli/feature-commands.js';
 import { writeSelftestRouteProof } from '../proof/selftest-proof-fixtures.js';
 import { createMission } from '../mission.js';
-import { formatSksUpdateCheckText, runSksUpdateCheck } from '../update-check.js';
+import { formatSksUpdateCheckText, runSksUpdateCheck, runSksUpdateNow } from '../update-check.js';
 export async function helpCommand(args = []) {
     const topic = args[0];
     if (topic)
@@ -109,6 +109,34 @@ export async function updateCheckCommand(args = []) {
         return printJson(result);
     console.log(`${sksTextLogo()}\n\n${formatSksUpdateCheckText(result)}`);
 }
+export async function updateCommand(sub = 'check', args = []) {
+    const action = String(sub || 'check').toLowerCase();
+    if (action === 'check' || action === 'status')
+        return updateCheckCommand(args);
+    if (action !== 'now') {
+        console.error('Usage: sks update check|now [--version <version>] [--json] [--dry-run]');
+        process.exitCode = 1;
+        return;
+    }
+    const result = await runSksUpdateNow({
+        version: valueAfter(args, '--version') || valueAfter(args, '-v'),
+        dryRun: flag(args, '--dry-run'),
+        timeoutMs: 10 * 60 * 1000,
+        maxOutputBytes: 128 * 1024
+    });
+    if (flag(args, '--json'))
+        return printJson(result);
+    console.log(`${sksTextLogo()}\n`);
+    console.log(`SKS update ${result.status}`);
+    if (result.command)
+        console.log(`Command: ${result.command}`);
+    if (result.global_root)
+        console.log(`Global root: ${result.global_root}`);
+    if (result.error)
+        console.log(`Error: ${result.error}`);
+    if (!result.ok)
+        process.exitCode = 1;
+}
 export async function setupCommand(args = []) {
     const root = await projectRoot();
     const installScope = installScopeFromArgs(args);
@@ -327,4 +355,11 @@ function whichSync(command) {
     });
     return result.status === 0 ? String(result.stdout || '').trim().split(/\r?\n/)[0] : null;
 }
+function valueAfter(args = [], name) {
+    const index = args.findIndex((arg) => String(arg) === name);
+    if (index < 0)
+        return null;
+    const value = args[index + 1];
+    return value === undefined ? null : String(value);
+}
 //# sourceMappingURL=basic-cli.js.map

package/dist/core/commands/local-model-command.js

@@ -0,0 +1,120 @@
+import { resolveOllamaWorkerConfig, writeLocalModelConfig, readLocalModelConfig } from '../agents/ollama-worker-config.js';
+export async function localModelCommand(args = []) {
+    const action = normalizeLocalModelAction(args[0]);
+    if (action === 'enable')
+        return emit(await enable(args.slice(1)), args);
+    if (action === 'disable')
+        return emit(await disable(), args);
+    if (action === 'set-model')
+        return emit(await setModel(args.slice(1)), args);
+    if (action === 'status')
+        return emit(await status(), args);
+    const result = { schema: 'sks.local-model-command.v1', ok: false, action, blockers: ['unknown_local_model_action'] };
+    process.exitCode = 1;
+    return emit(result, args);
+}
+function normalizeLocalModelAction(value) {
+    const text = String(value || 'status').trim().toLowerCase();
+    if (['on', 'enable', 'enabled', 'with-local-llm-on', '켜', '켜기'].includes(text))
+        return 'enable';
+    if (['off', 'disable', 'disabled', 'with-local-llm-off', '꺼', '끄기'].includes(text))
+        return 'disable';
+    if (['model', 'set', 'set-model'].includes(text))
+        return 'set-model';
+    if (['', 'status', 'state', 'check'].includes(text))
+        return 'status';
+    return text;
+}
+async function enable(args) {
+    const model = readOption(args, '--model', firstPositional(args) || '');
+    const baseUrl = readOption(args, '--base-url', '');
+    const think = readBoolFlag(args, '--think', '--no-think');
+    const patch = { enabled: true, provider: 'ollama' };
+    if (model)
+        patch.model = model;
+    if (baseUrl)
+        patch.base_url = baseUrl;
+    if (think !== null)
+        patch.think = think;
+    const config = await writeLocalModelConfig(patch);
+    return { schema: 'sks.local-model-command.v1', ok: true, action: 'enable', config };
+}
+async function disable() {
+    const config = await writeLocalModelConfig({ enabled: false });
+    return { schema: 'sks.local-model-command.v1', ok: true, action: 'disable', config };
+}
+async function setModel(args) {
+    const model = String(args[0] || '').trim();
+    if (!model) {
+        process.exitCode = 1;
+        return { schema: 'sks.local-model-command.v1', ok: false, action: 'set-model', blockers: ['model_missing'] };
+    }
+    const config = await writeLocalModelConfig({ model });
+    return { schema: 'sks.local-model-command.v1', ok: true, action: 'set-model', config };
+}
+async function status() {
+    const config = await readLocalModelConfig();
+    const resolved = await resolveOllamaWorkerConfig();
+    const api = await probeOllama(resolved.base_url);
+    return { schema: 'sks.local-model-command.v1', ok: true, action: 'status', config, resolved, api };
+}
+async function probeOllama(baseUrl) {
+    try {
+        const response = await fetch(`${baseUrl}/api/version`, { signal: AbortSignal.timeout(3000) });
+        const text = await response.text();
+        return { ok: response.ok, status: response.status, data: response.ok ? JSON.parse(text) : null };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function emit(result, args) {
+    if (args.includes('--json')) {
+        console.log(JSON.stringify(result, null, 2));
+        return result;
+    }
+    if (result.ok !== true) {
+        console.log(`Local model: blocked (${(result.blockers || []).join(', ') || 'unknown'})`);
+        return result;
+    }
+    const config = result.config || result.resolved || {};
+    console.log(`Local model: ${config.enabled ? 'enabled' : 'disabled'}`);
+    console.log(`Provider: ollama`);
+    console.log(`Model: ${config.model || 'unknown'}`);
+    console.log(`Base URL: ${config.base_url || config.baseUrl || 'unknown'}`);
+    if (typeof config.think === 'boolean')
+        console.log(`Think: ${config.think ? 'enabled' : 'disabled'}`);
+    if (result.api)
+        console.log(`Ollama API: ${result.api.ok ? 'ok' : 'not reachable'}`);
+    return result;
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return String(args[index + 1]);
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+function readBoolFlag(args, trueName, falseName) {
+    if (args.includes(trueName))
+        return true;
+    if (args.includes(falseName))
+        return false;
+    return null;
+}
+function firstPositional(args = []) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = String(args[i] || '');
+        if (arg === '--model' || arg === '--base-url') {
+            if (args[i + 1] && !String(args[i + 1]).startsWith('--'))
+                i += 1;
+            continue;
+        }
+        if (arg.startsWith('--model=') || arg.startsWith('--base-url='))
+            continue;
+        if (!arg.startsWith('--'))
+            return arg;
+    }
+    return '';
+}
+//# sourceMappingURL=local-model-command.js.map

package/dist/core/commands/mad-sks-command.js

@@ -4,7 +4,7 @@ import { spawn } from 'node:child_process';
 import { appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
 import { createMission, setCurrent } from '../mission.js';
-import { enableMadHighProfile, madHighProfileName } from '../auto-review.js';
+import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
 import { permissionGateSummary } from '../permission-gates.js';
 import { attachZellijSessionInteractive, launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
 import { createMadSksAuthorizationManifest, validateMadSksAuthorizationManifest } from '../mad-sks/authorization-manifest.js';
@@ -17,13 +17,14 @@ import { runMadSksExecutor } from '../mad-sks/executors/index.js';
 import { applyMadSksRollbackPlan } from '../mad-sks/rollback-apply.js';
 import { repairCodexConfigEperm } from '../codex/codex-config-eperm-repair.js';
 import { runCodexLaunchPreflight } from '../preflight/parallel-preflight-engine.js';
+import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/codex-app-ui-state-snapshot.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
         return madSksSubcommand(subcommand, args.filter((arg) => String(arg) !== subcommand));
     const cleanArgs = stripMadLaunchOnlyArgs(args);
     if (args.includes('--json')) {
-        const profile = await enableMadHighProfile();
+        const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = deps.maybePromptSksUpdateForLaunch ? await deps.maybePromptSksUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
@@ -55,16 +56,28 @@ export async function madHighCommand(args = [], deps = {}) {
         process.exitCode = 1;
         return;
     }
-    const profile = await enableMadHighProfile();
+    const profile = buildMadHighLaunchProfileNoWrite();
     const launchRoot = process.cwd();
     if (!(await exists(path.join(launchRoot, '.sneakoscope'))))
         await initProject(launchRoot, {});
+    const uiSnapshotId = Date.now().toString(36);
+    const beforeUi = await writeCodexAppUiSnapshot(launchRoot, `mad-before-${uiSnapshotId}`).catch(() => null);
     // launchFast skips the redundant live-`codex exec` config probe (up to ~20s, run
     // up to 3x via repair re-inspections): the real codex profile is exercised moments
     // later when the Zellij session opens. All filesystem/permission/EPERM/symlink/ACL
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
-    const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: true, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
+    const rawArgs = (args || []).map((arg) => String(arg));
+    const allowMadRepair = rawArgs.includes('--repair-config') || rawArgs.includes('--fix') || rawArgs.includes('--yes-repair');
+    const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: allowMadRepair, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
+    const afterPreflightUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-preflight-${uiSnapshotId}`).catch(() => null) : null;
+    const preflightUiDiff = beforeUi && afterPreflightUi ? diffCodexAppUiSnapshots(beforeUi, afterPreflightUi) : null;
+    if (preflightUiDiff && !preflightUiDiff.ok) {
+        await writeJsonAtomic(path.join(launchRoot, '.sneakoscope', 'reports', 'mad-codex-app-ui-preflight-diff.json'), preflightUiDiff);
+        console.error('SKS MAD launch changed Codex App UI state during preflight. Run `sks doctor --fix`.');
+        process.exitCode = 1;
+        return preflightUiDiff;
+    }
     if (!launchPreflight.ok) {
         console.error('SKS MAD launch blocked by config preflight.');
         for (const blocker of launchPreflight.blockers || [])
@@ -83,16 +96,30 @@ export async function madHighCommand(args = [], deps = {}) {
         SKS_MAD_SKS_TARGET_ROOT: madLaunch.gate.cwd,
         SKS_MAD_SKS_PROTECTED_CORE_DIGEST: madLaunch.gate.protected_core_digest
     };
-    const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
-        env: madSksEnv
-    });
     const launchOpts = codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: profile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
     const workspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`));
-    const launch = await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: madNativeSwarm.lane_count || 1, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
+    const launch = await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
+    const afterLaunchUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-launch-${uiSnapshotId}`).catch(() => null) : null;
+    const launchUiDiff = beforeUi && afterLaunchUi ? diffCodexAppUiSnapshots(beforeUi, afterLaunchUi) : null;
+    if (launchUiDiff) {
+        await writeJsonAtomic(path.join(madLaunch.dir, 'codex-app-ui-diff.json'), launchUiDiff);
+        if (!launchUiDiff.ok) {
+            console.error('SKS MAD launch changed Codex App UI state. Run `sks doctor --fix`.');
+            process.exitCode = 1;
+            return launchUiDiff;
+        }
+    }
     if (!launch.ok) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
         return launch;
     }
+    const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
+        env: {
+            ...madSksEnv,
+            SKS_ZELLIJ_SESSION_NAME: launch.session_name
+        },
+        zellijSessionName: launch.session_name
+    });
     // The launcher only creates a detached background session. In an interactive
     // terminal, immediately attach so the session actually opens for the user
     // instead of leaving them to copy/paste the attach command by hand.
@@ -162,6 +189,11 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         '--fast',
         '--json'
     ];
+    if (swarm.backend === 'zellij') {
+        command.push('--real');
+        command.push('--zellij-session-name', opts.zellijSessionName || `sks-${madLaunch.mission_id}`);
+        command.push('--zellij-pane-worker');
+    }
     const baseReport = {
         schema: 'sks.mad-sks-native-swarm.v1',
         ok: true,
@@ -176,6 +208,7 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         target_active_slots: swarm.agents,
         work_items: swarm.workItems,
         backend: swarm.backend,
+        zellij_session_name: opts.zellijSessionName || null,
         readonly: true,
         command,
         stdout_log: path.relative(root, stdoutLog),
@@ -228,7 +261,7 @@ export function resolveMadNativeSwarmOptions(args = [], profile = {}, opts = {})
     const disabled = list.includes('--no-swarm') || list.includes('--no-mad-swarm') || process.env.SKS_MAD_NATIVE_SWARM === '0';
     const agents = clampInt(readOption(list, '--mad-agents', readOption(list, '--mad-swarm-agents', process.env.SKS_MAD_SWARM_AGENTS || opts.agents || 5)), 1, 20);
     const workItems = clampInt(readOption(list, '--mad-swarm-work-items', process.env.SKS_MAD_SWARM_WORK_ITEMS || opts.workItems || agents), agents, 100);
-    const backend = String(readOption(list, '--mad-swarm-backend', process.env.SKS_MAD_SWARM_BACKEND || opts.backend || 'codex-sdk'));
+    const backend = defaultMadSwarmBackend(list, opts);
     return {
         enabled: !disabled,
         disabled_reason: disabled ? 'operator_disabled_mad_native_swarm' : null,
@@ -405,6 +438,9 @@ function madLaunchOnlyFlags() {
         '--mad-swarm-work-items',
         '--mad-swarm-backend',
         '--mad-swarm-prompt',
+        '--repair-config',
+        '--fix',
+        '--yes-repair',
         '--yes',
         '-y',
         '--dry-run',
@@ -420,6 +456,19 @@ function madLaunchValueFlags() {
         '--mad-swarm-prompt'
     ]);
 }
+export function defaultMadSwarmBackend(args = [], opts = {}) {
+    const list = (args || []).map((arg) => String(arg));
+    const explicit = readOption(list, '--mad-swarm-backend', null);
+    if (explicit)
+        return String(explicit);
+    if (process.env.SKS_MAD_SWARM_BACKEND)
+        return String(process.env.SKS_MAD_SWARM_BACKEND);
+    if (opts.backend)
+        return String(opts.backend);
+    if (list.includes('--json') || list.includes('--no-attach') || opts.nonInteractive === true)
+        return 'codex-sdk';
+    return 'zellij';
+}
 function stripMadLaunchOnlyArgs(args = []) {
     const flags = madLaunchOnlyFlags();
     const valueFlags = madLaunchValueFlags();