sneakoscope 4.8.7 → 5.1.2

package/dist/core/commands/route-success-helpers.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { exists, readJson, readText } from '../fsx.js';
+export async function context7EvidenceStatus(root, missionId = null) {
+    const candidates = [
+        missionId ? path.join(root, '.sneakoscope', 'missions', missionId, 'context7-evidence.jsonl') : null,
+        path.join(root, '.sneakoscope', 'state', 'context7-evidence.jsonl'),
+        path.join(root, '.sneakoscope', 'memory', 'q2_facts', 'stack-current-docs.md')
+    ].filter(Boolean);
+    for (const file of candidates) {
+        if (!(await exists(file)))
+            continue;
+        const text = await readText(file, '');
+        if (/\S/.test(text) && /(context7|resolve[-_]?library|query[-_]?docs|get[-_]?library|official docs|vendor docs)/i.test(text)) {
+            return { ok: true, policy: 'required_satisfied', evidence: path.relative(root, file).split(path.sep).join('/') };
+        }
+    }
+    return { ok: false, policy: 'required_not_satisfied', evidence: null, blocker: 'context7_policy_required_not_satisfied' };
+}
+export async function artifactPresence(root, dir, artifacts) {
+    const rows = await Promise.all(artifacts.map(async (artifact) => {
+        const file = path.isAbsolute(artifact) ? artifact : path.join(dir, artifact);
+        return { artifact, present: await exists(file) };
+    }));
+    const missing = rows.filter((row) => !row.present).map((row) => row.artifact);
+    return { ok: missing.length === 0, rows, missing };
+}
+export async function evaluateLocalGate(input) {
+    const missionDir = input.dir || (input.missionId ? path.join(input.root, '.sneakoscope', 'missions', input.missionId) : input.root);
+    const gatePath = path.isAbsolute(input.gateFile) ? input.gateFile : path.join(missionDir, input.gateFile);
+    const gate = await readJson(gatePath, null);
+    const blockers = [];
+    if (!gate)
+        blockers.push(`${path.basename(input.gateFile)}_missing`);
+    if (gate) {
+        if (!(gate.passed === true || gate.ok === true || gate.status === 'pass' || gate.status === 'passed'))
+            blockers.push('gate_not_passed');
+        if (gate.ok === false)
+            blockers.push('gate_ok_false');
+        if (Array.isArray(gate.blockers) && gate.blockers.length)
+            blockers.push(...gate.blockers.map(String));
+        if (Array.isArray(gate.missing_fields) && gate.missing_fields.length)
+            blockers.push(...gate.missing_fields.map((field) => `missing_field:${field}`));
+        for (const section of input.requiredSections || []) {
+            if (gate[section] == null)
+                blockers.push(`missing_gate_section:${section}`);
+        }
+    }
+    const artifactCheck = await artifactPresence(input.root, missionDir, input.requiredArtifacts || []);
+    blockers.push(...artifactCheck.missing.map((artifact) => `missing_artifact:${artifact}`));
+    const uniqueBlockers = [...new Set(blockers)];
+    return {
+        ok: uniqueBlockers.length === 0,
+        gate,
+        gate_path: gatePath,
+        blockers: uniqueBlockers,
+        artifacts: artifactCheck
+    };
+}
+//# sourceMappingURL=route-success-helpers.js.map

package/dist/core/commands/run-command.js

@@ -62,7 +62,15 @@ export async function runCommand(args = []) {
     return finalizeMockRun(root, { id, route, prompt, args, classification, mode });
 }
 async function finalizeMockRun(root, { id, route, prompt, args, classification, mode, }) {
-    const gate = { schema: 'sks.run-gate.v1', ok: true, passed: true, route: route.command, mock: true };
+    const gate = {
+        schema: 'sks.run-gate.v1',
+        ok: false,
+        passed: false,
+        route: route.command,
+        mock: true,
+        execution_class: 'mock_fixture',
+        blockers: ['run_mock_fixture_cannot_claim_real_completion']
+    };
     await writeJsonAtomic(path.join(missionDir(root, id), 'run-gate.json'), gate);
     const proof = await finalizeRoute(root, {
         missionId: id,
@@ -76,19 +84,20 @@ async function finalizeMockRun(root, { id, route, prompt, args, classification,
         command: { cmd: `sks run "${prompt}" --mock`, status: 0 },
     });
     const trust = await loadTrustReport(root, id);
+    const completionOk = proof.ok && proof.proof?.status !== 'mock_only' && gate.passed === true;
     await setCurrent(root, {
         mission_id: id,
         mode: 'RUN',
         route: route.id,
         route_command: route.command,
-        phase: proof.ok ? 'RUN_MOCK_FINALIZED' : 'RUN_MOCK_BLOCKED',
+        phase: completionOk ? 'RUN_MOCK_FINALIZED' : 'RUN_MOCK_BLOCKED',
         implementation_allowed: true,
         completion_proof: 'completion-proof.json',
         trust_report: 'trust-report.json',
     });
     const result = {
         schema: 'sks.run.v2',
-        ok: proof.ok,
+        ok: completionOk,
         mission_id: id,
         route: route.command,
         mode,
@@ -98,6 +107,8 @@ async function finalizeMockRun(root, { id, route, prompt, args, classification,
         completion_proof: { ok: proof.ok, validation: proof.validation },
         trust_report: trust,
     };
+    if (!result.ok)
+        process.exitCode = 1;
     if (flag(args, '--json')) {
         console.log(JSON.stringify(result, null, 2));
         return result;
@@ -235,7 +246,7 @@ async function executeRouteCommand(root, route, prompt, { auto = false } = {}) {
     return routeExecutionResult(route, ['sks', ...commandArgs].join(' '), result, {
         okStatus: 'completed',
         trustStatus: 'verified_partial',
-        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' || route.command === '$with-local-llm-on' || route.command === '$Commit' || route.command === '$Commit-And-Push' || route.command === '$Ultra-Search' || route.command === '$SEO-GEO-OPTIMIZER' ? 'safe_deterministic' : 'mock_safe',
+        executionKind: 'live_route',
     });
 }
 async function runAutoVerification(root, missionId) {
@@ -304,7 +315,7 @@ function routeExecutionResult(route, command, result, options = {}) {
         schema: 'sks.run-route-execution.v1',
         ok,
         status: ok ? (options.okStatus || 'completed') : 'blocked',
-        execution_kind: ok ? (options.executionKind || 'safe_deterministic') : 'blocked',
+        execution_kind: ok ? (options.executionKind || 'live_route') : 'blocked',
         route: route.command,
         command,
         exit_code: result.code,
@@ -314,7 +325,7 @@ function routeExecutionResult(route, command, result, options = {}) {
         trust_status: ok ? options.trustStatus || 'verified_partial' : 'blocked',
         blockers: ok ? [] : ['route_command_failed'],
         unverified: ok
-            ? options.unverified || ['sks run --execute used the deterministic safe route command path; real external dependencies remain route-specific.']
+            ? options.unverified || ['sks run --execute ran the selected route command; route-specific gates remain authoritative for final trust.']
             : [],
         next_action: ok ? 'review completion proof and trust report' : 'inspect run-route-execution.json stderr_tail',
     };
@@ -538,7 +549,7 @@ async function writeLightweightTrustReport(root, missionId, route, statusHint, p
     const report = {
         schema: TRUST_REPORT_SCHEMA,
         ...trustKernelMetadata(),
-        ok: proofOk && !['blocked', 'failed', 'not_verified'].includes(status),
+        ok: proofOk && !['blocked', 'failed', 'not_verified', 'mock_only'].includes(status),
         mission_id: missionId,
         route,
         status,
@@ -551,6 +562,7 @@ async function writeLightweightTrustReport(root, missionId, route, statusHint, p
             lightweight: true,
             reason: 'safe_deterministic_run_wrapper'
         },
+        trust_basis: 'lightweight',
         evidence: {
             completion_proof: `.sneakoscope/missions/${missionId}/completion-proof.json`,
             route_contract: null,

package/dist/core/commands/seo-command.js

@@ -2,7 +2,8 @@ import path from 'node:path';
 import { printJson } from '../../cli/output.js';
 import { projectRoot } from '../fsx.js';
 import { flag, readOption } from './command-utils.js';
-import { runSearchVisibilityApply, runSearchVisibilityAudit, runSearchVisibilityDoctor, runSearchVisibilityFixture, runSearchVisibilityPlan, runSearchVisibilityRollback, runSearchVisibilityStatus, runSearchVisibilityVerify, } from '../search-visibility/index.js';
+import { runSearchVisibilityApply, runSearchVisibilityAudit, runSearchVisibilityDoctor, runSearchVisibilityFixture, runSearchVisibilityPlan, runSearchVisibilityRollback, runSearchVisibilityStatus, runSearchVisibilityVerify, resolveSearchVisibilityMission, } from '../search-visibility/index.js';
+import { evaluateLocalGate } from './route-success-helpers.js';
 export async function seoCommand(args = []) {
     return runSearchVisibilityCommand('seo', args, 'seo');
 }
@@ -15,6 +16,26 @@ export async function runSearchVisibilityCommand(mode, args = [], displayCommand
     const rest = args.slice(1);
     const options = await parseOptions(rest);
     let result;
+    if (action === 'apply' && options.apply) {
+        const mission = await resolveSearchVisibilityMission(options.root, firstPositional(rest) || 'latest');
+        const blockers = [];
+        if (!mission)
+            blockers.push('mission_required_for_apply');
+        else {
+            const planGate = await evaluateLocalGate({ root: mission.root, dir: mission.dir, gateFile: mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json', requiredArtifacts: ['search-visibility/mutation-plan.json'] });
+            blockers.push(...planGate.blockers.filter((blocker) => blocker !== 'gate_not_passed' && blocker !== 'gate_ok_false'));
+        }
+        if (blockers.length) {
+            result = { schema: 'sks.search-visibility.apply-command.v1', ok: false, route: mode === 'seo' ? '$SEO-GEO-OPTIMIZER' : '$SEO-GEO-OPTIMIZER', status: 'blocked', blockers };
+            process.exitCode = 1;
+            if (options.json) {
+                printJson(result);
+                return result;
+            }
+            printHuman(mode, action, result);
+            return result;
+        }
+    }
     if (action === 'doctor')
         result = await runSearchVisibilityDoctor(mode, options);
     else if (action === 'audit')
@@ -33,6 +54,7 @@ export async function runSearchVisibilityCommand(mode, args = [], displayCommand
         result = await runSearchVisibilityFixture(mode, options);
     else
         return usage(mode, 2, displayCommand);
+    result = await applySearchVisibilityGateResult(mode, action, result, options);
     if (isBlocked(result))
         process.exitCode = 1;
     if (options.json) {
@@ -42,6 +64,32 @@ export async function runSearchVisibilityCommand(mode, args = [], displayCommand
     printHuman(mode, action, result);
     return result;
 }
+async function applySearchVisibilityGateResult(mode, action, result, options) {
+    if (!result || typeof result !== 'object' || !result.mission_id)
+        return result;
+    const mission = await resolveSearchVisibilityMission(options.root, result.mission_id);
+    if (!mission)
+        return { ...result, ok: false, blockers: [...(result.blockers || []), 'mission_missing_for_gate_evaluation'] };
+    const requiredArtifacts = action === 'apply'
+        ? ['search-visibility/mutation-plan.json', 'search-visibility/rollback-manifest.json', 'search-visibility/verification-report.json']
+        : action === 'status'
+            ? []
+            : ['search-visibility/verification-report.json'];
+    const evaluated = await evaluateLocalGate({
+        root: mission.root,
+        dir: mission.dir,
+        gateFile: mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json',
+        requiredArtifacts
+    });
+    const blockers = [...new Set([...(result.blockers || []), ...evaluated.blockers])];
+    return {
+        ...result,
+        ok: result.ok === true && evaluated.ok === true,
+        status: result.ok === true && evaluated.ok === true ? result.status : 'blocked',
+        gate_evaluation: evaluated,
+        blockers
+    };
+}
 function normalizeOptimizerArgs(args) {
     const out = [...args];
     const first = String(out[0] || '').toLowerCase();

package/dist/core/commands/ui-command.js

@@ -0,0 +1,161 @@
+import * as http from 'node:http';
+import path from 'node:path';
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { ui } from '../../cli/cli-theme.js';
+import { DASHBOARD_HTML } from '../ui/dashboard-html.js';
+import { findLatestMission, missionDir } from '../mission.js';
+import { nowIso, projectRoot, readJson, readText, runProcess } from '../fsx.js';
+import { readZellijSlotTelemetrySnapshot } from '../zellij/zellij-slot-telemetry.js';
+export async function uiCommand(args = []) {
+    const root = path.resolve(String(readOption(args, '--root', '') || await projectRoot()));
+    if (flag(args, '--once')) {
+        const state = await collectUiState(root, String(readOption(args, '--mission', 'latest') || 'latest'));
+        if (flag(args, '--json'))
+            return printJson(state);
+        ui.banner('ui');
+        ui.ok(`state ${state.mission_id || 'latest'} ${state.gates.length} gates`);
+        return state;
+    }
+    const requestedPort = Number(readOption(args, '--port', '4477'));
+    const port = Number.isFinite(requestedPort) && requestedPort > 0 ? Math.floor(requestedPort) : 4477;
+    const mission = String(readOption(args, '--mission', 'latest') || 'latest');
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url || '/', 'http://127.0.0.1');
+            if (url.pathname === '/') {
+                res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+                res.end(DASHBOARD_HTML);
+                return;
+            }
+            if (url.pathname === '/events')
+                return sseStream(res, root, String(url.searchParams.get('mission') || mission));
+            if (url.pathname === '/api/state') {
+                res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(JSON.stringify(await collectUiState(root, String(url.searchParams.get('mission') || mission))));
+                return;
+            }
+            res.writeHead(404);
+            res.end('not found');
+        }
+        catch (err) {
+            res.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+            res.end(JSON.stringify({ ok: false, error: sanitizeText(err?.message || String(err)) }));
+        }
+    });
+    const actualPort = await listenLocal(server, port);
+    const url = `http://127.0.0.1:${actualPort}`;
+    ui.banner('ui');
+    ui.ok(`dashboard ${url}`);
+    void runProcess('/usr/bin/open', [url], { timeoutMs: 5000, maxOutputBytes: 4096 }).catch(() => undefined);
+    return new Promise(() => undefined);
+}
+export async function collectUiState(root, missionInput = 'latest') {
+    const missionId = missionInput === 'latest' ? await findLatestMission(root) : missionInput;
+    const snapshot = missionId ? await readZellijSlotTelemetrySnapshot(root, missionId).catch(() => null) : null;
+    const gates = missionId ? await readLatestGateSummaries(root, missionId) : [];
+    const events = missionId ? await tailJsonl(path.join(missionDir(root, missionId), 'events.jsonl'), 30) : [];
+    const mission = missionId ? await readJson(path.join(missionDir(root, missionId), 'mission.json'), null).catch(() => null) : null;
+    return sanitizeForUi({
+        schema: 'sks.ui-state.v1',
+        ok: true,
+        ts: nowIso(),
+        mission_id: missionId,
+        route: mission?.mode || mission?.route || null,
+        snapshot,
+        gates,
+        events
+    });
+}
+async function sseStream(res, root, mission) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache, no-store',
+        connection: 'keep-alive'
+    });
+    const tick = async () => {
+        const state = await collectUiState(root, mission).catch((err) => ({ ok: false, ts: nowIso(), error: sanitizeText(err?.message || String(err)) }));
+        res.write(`data: ${JSON.stringify(state)}\n\n`);
+    };
+    await tick();
+    const timer = setInterval(tick, 1000);
+    res.on('close', () => clearInterval(timer));
+}
+async function readLatestGateSummaries(root, missionId) {
+    const dir = missionDir(root, missionId);
+    const files = ['stop-gate.json', 'naruto-gate.json', 'team-gate.json', 'qa-gate.json', 'reflection-gate.json', 'completion-proof.json'];
+    const rows = [];
+    for (const file of files) {
+        const gate = await readJson(path.join(dir, file), null).catch(() => null);
+        if (!gate)
+            continue;
+        rows.push({
+            id: file,
+            ok: gate.passed === true || gate.ok === true || gate.status === 'passed',
+            missing: Array.isArray(gate.missing) ? gate.missing : Array.isArray(gate.blockers) ? gate.blockers : [],
+            source: `.sneakoscope/missions/${missionId}/${file}`
+        });
+    }
+    return rows;
+}
+async function tailJsonl(file, limit) {
+    const text = await readText(file, '').catch(() => '');
+    return String(text || '').split(/\r?\n/).filter(Boolean).slice(-limit).map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return { ts: null, type: 'raw', text: line.slice(0, 500) };
+        }
+    });
+}
+async function listenLocal(server, startPort) {
+    for (let offset = 0; offset < 20; offset += 1) {
+        const port = startPort + offset;
+        const result = await new Promise((resolve) => {
+            const onError = (err) => {
+                server.off('listening', onListen);
+                resolve({ ok: false, code: err.code || 'listen_failed' });
+            };
+            const onListen = () => {
+                server.off('error', onError);
+                resolve({ ok: true });
+            };
+            server.once('error', onError);
+            server.once('listening', onListen);
+            server.listen(port, '127.0.0.1');
+        });
+        if (result.ok)
+            return port;
+        if (result.code !== 'EADDRINUSE')
+            throw new Error(`dashboard listen failed: ${result.code}`);
+    }
+    throw new Error('dashboard listen failed: no available localhost port');
+}
+function sanitizeForUi(value) {
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeForUi(item));
+    if (!value || typeof value !== 'object')
+        return typeof value === 'string' ? sanitizeText(value) : value;
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (/(?:key|token|secret|password|credential|cookie|auth)/i.test(key))
+            continue;
+        out[key] = sanitizeForUi(child);
+    }
+    return out;
+}
+function sanitizeText(value) {
+    return String(value || '')
+        .replace(/sk-[A-Za-z0-9_-]{12,}/g, '[redacted]')
+        .replace(/(?:api[_-]?key|secret|token|password|credential)/ig, '[redacted-field]')
+        .slice(0, 2000);
+}
+function readOption(args = [], name, fallback = null) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=ui-command.js.map

package/dist/core/commands/uninstall-command.js

@@ -4,10 +4,12 @@ import fsp from 'node:fs/promises';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { ensureDir, exists, readJson, readText, runProcess, writeJsonAtomic } from '../fsx.js';
+import { ui as cliUi } from '../../cli/cli-theme.js';
 import { uninstallSksMenuBar } from '../codex-app/sks-menubar.js';
 import { writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
 import { sweepSksTempDirs } from '../retention.js';
 import { reconcileSkills } from '../init/skills.js';
+import { removeTriwikiAgentsMdBlocks } from '../triwiki/agents-md-projector.js';
 export async function uninstallCommand(args = []) {
     const opts = {
         yes: hasFlag(args, '--yes') || hasFlag(args, '-y'),
@@ -24,8 +26,11 @@ export async function uninstallCommand(args = []) {
         const result = { schema: 'sks.uninstall.v1', ok: true, dry_run: true, inventory };
         if (opts.json)
             console.log(JSON.stringify(result, null, 2));
-        else
+        else {
+            cliUi.banner('uninstall');
+            cliUi.warn('dry run only');
             printInventoryTable(inventory);
+        }
         return result;
     }
     if (!opts.yes && !(await confirmUninstall())) {
@@ -66,6 +71,8 @@ export async function uninstallCommand(args = []) {
     if (opts.json)
         console.log(JSON.stringify(report, null, 2));
     else {
+        cliUi.banner('uninstall');
+        report.ok ? cliUi.ok('removed configured SKS surfaces') : cliUi.fail('uninstall completed with errors');
         console.log('SKS uninstall complete.');
         console.log('Final package removal command: npm uninstall -g sneakoscope');
     }
@@ -84,6 +91,7 @@ async function collectSksInventory(opts) {
         ['hooks-json', path.join(home, '.codex', 'hooks.json'), 'strip SKS-managed hooks', '--keep-config'],
         ['sks-home', path.join(home, '.sneakoscope'), 'remove', '--keep-data'],
         ['sks-global-home', path.join(home, '.sneakoscope-global'), 'remove', '--keep-data'],
+        ['agents-md-memory-block', path.join(opts.root, 'AGENTS.md'), 'strip SKS Project Memory block', '--purge-projects'],
         ['tmp', os.tmpdir(), 'sweep sks temp dirs', 'default']
     ];
     const out = [];
@@ -263,6 +271,12 @@ async function purgeProjectArtifacts(report, opts) {
             report.errors.push({ id: 'project-skills', root, error: err?.message || String(err) });
         });
         await fsp.rm(path.join(root, '.codex'), { recursive: true, force: true }).catch(() => null);
+        const removedBlocks = await removeTriwikiAgentsMdBlocks(root).catch((err) => {
+            report.errors.push({ id: 'agents-md-memory-block', root, error: err?.message || String(err) });
+            return [];
+        });
+        if (removedBlocks.length)
+            report.removed.push({ id: 'agents-md-memory-block', root, result: { ok: true, files: removedBlocks.length } });
         await fsp.rm(path.join(root, 'SNEAKOSCOPE.md'), { force: true }).catch(() => null);
         if (!opts.keepData)
             await fsp.rm(path.join(root, '.sneakoscope'), { recursive: true, force: true }).catch(() => null);

package/dist/core/db-safety.js

@@ -609,8 +609,8 @@ export function dbBlockReason(decision) {
     return [
         'Sneakoscope Codex Database Safety Gate blocked this operation.',
         `Reasons: ${(decision.reasons || []).join(', ') || 'unknown'}.`,
-        'Default DB mode is read-only. Destructive SQL-plane operations require an explicit active MadDB v2 capability opened by $MAD-DB or sks mad-db run|exec|apply-migration.',
-        'Use read-only/project-scoped Supabase MCP URLs outside MadDB. Supabase project/account/billing/credential control-plane operations remain denied even in MadDB.'
+        'Default DB mode is read-only. Destructive SQL-plane operations require an explicit active MAD-SKS sql-plane capability opened by $MAD-SKS/sks mad-sks sql|apply-migration or the deprecated $MAD-DB/sks mad-db redirect.',
+        'Use read-only/project-scoped Supabase MCP URLs outside MAD-SKS sql-plane. Supabase project/account/billing/credential control-plane operations remain denied even there.'
     ].join(' ');
 }
 export async function scanDbSafety(root, opts = {}) {

package/dist/core/doctor/doctor-transaction.js

@@ -1,14 +1,18 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { isDoctorPhaseClean, markDoctorPhaseClean } from './doctor-dirty-planner.js';
+import { ui as cliUi } from '../../cli/cli-theme.js';
 export async function runDoctorFixTransaction(input) {
     const startedAt = nowIso();
     const phases = [];
     const proofIdsUsed = [];
     let rollbackPerformed = false;
+    const liveOutput = input.json !== true && input.machineOnly !== true;
     for (const definition of input.phases) {
         const phaseStarted = nowIso();
         const startedMs = Date.now();
+        if (liveOutput)
+            cliUi.step(`▸ ${definition.id} ...`);
         let phase = {
             id: definition.id,
             ok: false,
@@ -32,6 +36,8 @@ export async function runDoctorFixTransaction(input) {
                 completed_at: nowIso(),
                 duration_ms: Math.max(0, Date.now() - startedMs)
             });
+            if (liveOutput)
+                cliUi.step(`✔ ${definition.id} (${Math.round((Date.now() - startedMs) / 1000)}s)`);
             continue;
         }
         try {
@@ -71,6 +77,8 @@ export async function runDoctorFixTransaction(input) {
             proofIdsUsed.push(proofId);
         }
         phases.push(phase);
+        if (liveOutput)
+            cliUi.step(`${phase.ok ? '✔' : '✖'} ${definition.id} (${Math.round((phase.duration_ms || 0) / 1000)}s)`);
     }
     const writeInput = {
         root: input.root,

package/dist/core/doctor/doctor-zellij-repair.js

@@ -10,6 +10,7 @@ export async function runDoctorZellijRepair(input) {
         autoApprove: args.includes('--yes') || args.includes('-y'),
         installHomebrew: args.includes('--install-homebrew') || process.env.SKS_ALLOW_HOMEBREW_INSTALL === '1',
         dryRun: args.includes('--dry-run'),
+        quiet: args.includes('--json') || args.includes('--machine-only'),
         interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY && process.env.SKS_NO_QUESTION !== '1'),
         allowHeadlessFallback: false,
         env: process.env

package/dist/core/doctor/imagegen-repair.js

@@ -0,0 +1,161 @@
+import path from 'node:path';
+import { CODEX_APP_IMAGE_GENERATION_DOC_URL } from '../routes.js';
+import { detectImagegenCapability } from '../imagegen/imagegen-capability.js';
+import { ensureDir, nowIso, runProcess, which, writeJsonAtomic } from '../fsx.js';
+export const DOCTOR_IMAGEGEN_REPAIR_SCHEMA = 'sks.doctor-imagegen-repair.v1';
+export async function repairCodexImagegen(input) {
+    const root = path.resolve(input.root || process.cwd());
+    const apply = input.apply === true;
+    const steps = [];
+    const before = await detectImagegenCapability({
+        codexBin: input.codexBin || undefined,
+        timeoutMs: input.timeoutMs || 5000
+    }).catch((err) => ({ ok: false, core_ready: false, blockers: [messageOf(err)], codex_app: { available: false, blocker: messageOf(err) } }));
+    let codexBin = input.codexBin || await which('codex').catch(() => null);
+    let versionStep;
+    if (codexBin) {
+        const version = await runProcess(codexBin, ['--version'], { timeoutMs: input.timeoutMs || 5000, maxOutputBytes: 16 * 1024 })
+            .catch((err) => ({ code: 1, stdout: '', stderr: messageOf(err) }));
+        versionStep = {
+            id: 'codex_cli_version',
+            ok: version.code === 0,
+            attempted: true,
+            command: `${codexBin} --version`,
+            exit_code: version.code,
+            stdout_tail: tail(version.stdout),
+            stderr_tail: tail(version.stderr),
+            blocker: version.code === 0 ? null : 'codex_cli_version_failed'
+        };
+    }
+    else {
+        versionStep = {
+            id: 'codex_cli_version',
+            ok: false,
+            attempted: false,
+            command: 'codex --version',
+            blocker: 'codex_binary_missing'
+        };
+    }
+    steps.push(versionStep);
+    if (!codexBin && apply && (input.autoInstallCodex === true || process.env.SKS_IMAGEGEN_AUTO_INSTALL_CODEX === '1')) {
+        const npmBin = await which('npm').catch(() => null);
+        if (npmBin) {
+            const install = await runProcess(npmBin, ['i', '-g', '@openai/codex@latest'], {
+                timeoutMs: 180000,
+                maxOutputBytes: 128 * 1024
+            }).catch((err) => ({ code: 1, stdout: '', stderr: messageOf(err) }));
+            steps.push({
+                id: 'codex_cli_install',
+                ok: install.code === 0,
+                attempted: true,
+                command: `${npmBin} i -g @openai/codex@latest`,
+                exit_code: install.code,
+                stdout_tail: tail(install.stdout),
+                stderr_tail: tail(install.stderr),
+                blocker: install.code === 0 ? null : 'codex_cli_install_failed'
+            });
+            codexBin = await which('codex').catch(() => null);
+        }
+        else {
+            steps.push({
+                id: 'codex_cli_install',
+                ok: false,
+                attempted: false,
+                command: 'npm i -g @openai/codex@latest',
+                blocker: 'npm_missing'
+            });
+        }
+    }
+    else if (!codexBin) {
+        steps.push({
+            id: 'codex_cli_install',
+            ok: false,
+            attempted: false,
+            command: 'npm i -g @openai/codex@latest',
+            blocker: apply ? 'auto_install_requires_SKS_IMAGEGEN_AUTO_INSTALL_CODEX_1' : 'doctor_fix_not_requested'
+        });
+    }
+    if (codexBin && before?.core_ready !== true && apply) {
+        const enable = await runProcess(codexBin, ['features', 'enable', 'image_generation'], {
+            timeoutMs: input.timeoutMs || 10000,
+            maxOutputBytes: 32 * 1024
+        }).catch((err) => ({ code: 1, stdout: '', stderr: messageOf(err) }));
+        steps.push({
+            id: 'image_generation_feature_enable',
+            ok: enable.code === 0,
+            attempted: true,
+            command: `${codexBin} features enable image_generation`,
+            exit_code: enable.code,
+            stdout_tail: tail(enable.stdout),
+            stderr_tail: tail(enable.stderr),
+            blocker: enable.code === 0 ? null : 'codex_feature_enable_unsupported_or_failed'
+        });
+    }
+    else {
+        steps.push({
+            id: 'image_generation_feature_enable',
+            ok: before?.core_ready === true,
+            attempted: false,
+            command: codexBin ? `${codexBin} features enable image_generation` : 'codex features enable image_generation',
+            blocker: before?.core_ready === true ? null : apply ? 'codex_cli_missing' : 'doctor_fix_not_requested'
+        });
+    }
+    const after = await detectImagegenCapability({
+        codexBin: codexBin || undefined,
+        timeoutMs: input.timeoutMs || 5000
+    }).catch((err) => ({ ok: false, core_ready: false, blockers: [messageOf(err)], codex_app: { available: false, blocker: messageOf(err) } }));
+    steps.push({
+        id: 'imagegen_capability_redetect',
+        ok: after?.core_ready === true,
+        attempted: true,
+        command: 'codex features list --json',
+        blocker: after?.core_ready === true ? null : 'codex_app_builtin_imagegen_capability_missing'
+    });
+    const recovered = after?.core_ready === true;
+    const blockers = recovered ? [] : [
+        ...new Set([
+            ...(after?.core_blockers || []),
+            ...(after?.blockers || []),
+            'codex_imagegen_unavailable'
+        ].map(String))
+    ];
+    let report = {
+        schema: DOCTOR_IMAGEGEN_REPAIR_SCHEMA,
+        generated_at: nowIso(),
+        ok: recovered,
+        attempted: before?.core_ready !== true,
+        apply,
+        recovered,
+        before,
+        after,
+        steps,
+        blockers,
+        manual_actions: recovered ? [] : [
+            `Install/update Codex CLI if missing: npm i -g @openai/codex@latest`,
+            `Open Codex App settings and enable image_generation / $imagegen.`,
+            `Verify with: codex features list --json`,
+            `Docs: ${CODEX_APP_IMAGE_GENERATION_DOC_URL}`
+        ],
+        docs_url: CODEX_APP_IMAGE_GENERATION_DOC_URL
+    };
+    if (input.reportPath !== null) {
+        const reportPath = input.reportPath || path.join(root, '.sneakoscope', 'reports', 'doctor-imagegen-repair.json');
+        try {
+            await ensureDir(path.dirname(reportPath));
+            await writeJsonAtomic(reportPath, report);
+            report = { ...report, report_path: reportPath };
+        }
+        catch (err) {
+            report = { ...report, report_write_failed: true, report_write_error: messageOf(err) };
+        }
+    }
+    return report;
+}
+function tail(value, max = 2000) {
+    const text = String(value || '');
+    return text.length > max ? text.slice(-max) : text;
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=imagegen-repair.js.map