sneakoscope 4.8.7 → 5.3.0

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

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { projectRoot, readText, runProcess, writeJsonAtomic, nowIso } from '../fsx.js';
+import { ui } from '../../cli/cli-theme.js';
+import { runCompiledRules } from '../verification/mistake-rule-compiler.js';
+const LENSES = [
+    'review-correctness',
+    'review-security',
+    'review-lean',
+    'review-regression'
+];
+export async function reviewCommand(args = []) {
+    const root = path.resolve(String(readOption(args, '--root', '') || await projectRoot()));
+    const diff = await collectDiff(root, args);
+    if (!diff.files.length) {
+        const report = buildReport({ files: [], machine: { checks: [], findings: [] }, lenses: [], fix: null });
+        if (flag(args, '--json'))
+            return printJson(report);
+        ui.banner('review');
+        ui.ok('변경 없음');
+        return report;
+    }
+    const [machine, lenses] = await Promise.all([
+        runMachineChecks(root, diff),
+        runReadOnlyReviewLenses(diff)
+    ]);
+    let fix = null;
+    if (flag(args, '--fix'))
+        fix = await attemptMachineFix(root, machine.findings);
+    const report = buildReport({ files: diff.files, machine, lenses, fix });
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'review-report.json'), report);
+    if (flag(args, '--json'))
+        return printJson(report);
+    printReviewReport(report);
+    if (report.verdict === 'blocked')
+        process.exitCode = 1;
+    return report;
+}
+async function collectDiff(root, args) {
+    const staged = flag(args, '--staged');
+    const ref = String(readOption(args, '--diff', '') || '');
+    const nameArgs = staged ? ['diff', '--staged', '--name-only'] : ref ? ['diff', ref, '--name-only'] : ['diff', '--name-only'];
+    const diffArgs = staged ? ['diff', '--staged', '--no-ext-diff'] : ref ? ['diff', ref, '--no-ext-diff'] : ['diff', '--no-ext-diff'];
+    const names = await runProcess('git', nameArgs, { cwd: root, timeoutMs: 15000, maxOutputBytes: 256 * 1024 });
+    const body = await runProcess('git', diffArgs, { cwd: root, timeoutMs: 15000, maxOutputBytes: 2 * 1024 * 1024 });
+    const files = String(names.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    return {
+        mode: staged ? 'staged' : ref ? `diff:${ref}` : 'worktree',
+        files,
+        text: body.stdout || '',
+        command: ['git', ...diffArgs].join(' ')
+    };
+}
+async function runMachineChecks(root, diff) {
+    const findings = [];
+    const checks = [];
+    findings.push(...await conflictMarkerFindings(root, diff.files));
+    findings.push(...secretPatternFindings(diff.text));
+    const mistakeRules = await runCompiledRules(root, diff.files).catch((err) => ({
+        ok: false,
+        violations: [{ rule_id: 'mistake-rule-runner', severity: 'error', file: '', line: 0, description: err instanceof Error ? err.message : String(err), good_example: '' }],
+        rule_count: 0
+    }));
+    checks.push({ command: 'sks mistake rules', ok: mistakeRules.ok });
+    for (const violation of mistakeRules.violations || []) {
+        findings.push({
+            id: `machine:mistake-rule:${violation.rule_id}:${violation.file}:${violation.line}`,
+            severity: violation.severity === 'error' ? 'blocker' : 'medium',
+            evidence: 'machine',
+            source: 'mistake-rule',
+            ...(violation.file ? { file: violation.file } : {}),
+            ...(violation.line ? { line: violation.line } : {}),
+            message: `${violation.description}${violation.good_example ? ` | good: ${singleLine(violation.good_example)}` : ''}`
+        });
+    }
+    if (diff.files.some((file) => /\.(ts|tsx|mts|cts)$/.test(file))) {
+        const command = 'tsc -p tsconfig.json --noEmit';
+        const result = await runProcess('npx', ['tsc', '-p', 'tsconfig.json', '--noEmit'], {
+            cwd: root,
+            timeoutMs: 120000,
+            maxOutputBytes: 512 * 1024
+        });
+        checks.push({ command, ok: result.code === 0, code: result.code });
+        if (result.code !== 0) {
+            findings.push({
+                id: 'machine:typecheck',
+                severity: 'blocker',
+                evidence: 'machine',
+                source: 'typescript',
+                message: summarizeProcessOutput(result.stderr || result.stdout || 'TypeScript check failed.'),
+                command
+            });
+        }
+    }
+    return { checks, findings, summary: { check_count: checks.length, finding_count: findings.length } };
+}
+async function conflictMarkerFindings(root, files) {
+    const findings = [];
+    for (const file of files) {
+        const abs = path.join(root, file);
+        const text = await readText(abs, '').catch(() => '');
+        const lines = String(text || '').split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            if (/^(<<<<<<<|=======|>>>>>>>)(?:\s|$)/.test(lines[index] || '')) {
+                findings.push({
+                    id: `machine:conflict:${file}:${index + 1}`,
+                    severity: 'blocker',
+                    evidence: 'machine',
+                    source: 'conflict-marker-scan',
+                    file,
+                    line: index + 1,
+                    message: 'Git conflict marker remains in a changed file.'
+                });
+            }
+        }
+    }
+    return findings;
+}
+function secretPatternFindings(diffText) {
+    const findings = [];
+    const patterns = [
+        /(?:api[_-]?key|secret|token|password)\s*[:=]\s*['"][^'"]{12,}['"]/i,
+        /sk-[A-Za-z0-9_-]{20,}/
+    ];
+    const lines = diffText.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] || '';
+        if (!line.startsWith('+') || line.startsWith('+++'))
+            continue;
+        if (patterns.some((pattern) => pattern.test(line))) {
+            findings.push({
+                id: `machine:secret:${index + 1}`,
+                severity: 'blocker',
+                evidence: 'machine',
+                source: 'diff-secret-scan',
+                line: index + 1,
+                message: 'Added diff line looks like a secret or credential.'
+            });
+        }
+    }
+    return findings;
+}
+async function runReadOnlyReviewLenses(diff) {
+    return LENSES.map((role) => ({
+        role,
+        evidence: 'llm',
+        status: 'not_run',
+        findings: [],
+        unverified: [`${role} native read-only worker not run in this local review invocation`],
+        files: diff.files.length
+    }));
+}
+async function attemptMachineFix(root, findings) {
+    const machine = findings.filter((finding) => finding.evidence === 'machine');
+    if (!machine.length)
+        return { attempted: false, reason: 'no_machine_findings' };
+    const pkg = JSON.parse(await readText(path.join(root, 'package.json'), '{}'));
+    if (pkg?.scripts?.lint && String(pkg.scripts.lint).includes('--fix')) {
+        const result = await runProcess('npm', ['run', 'lint', '--', '--fix'], { cwd: root, timeoutMs: 120000, maxOutputBytes: 512 * 1024 });
+        return { attempted: true, command: 'npm run lint -- --fix', ok: result.code === 0, code: result.code };
+    }
+    return { attempted: false, reason: 'no_safe_machine_fixer_available', machine_findings: machine.length };
+}
+function buildReport(input) {
+    const findings = dedupeFindings([...(input.machine.findings || []), ...input.lenses.flatMap((lens) => lens.findings || [])]);
+    const verdict = findings.some((finding) => finding.severity === 'blocker') ? 'blocked' : findings.length ? 'needs_attention' : 'clean';
+    return {
+        schema: 'sks.review-report.v1',
+        generated_at: nowIso(),
+        files: input.files.length,
+        machine: input.machine.summary || { check_count: 0, finding_count: 0 },
+        lenses: input.lenses,
+        findings,
+        fix: input.fix,
+        verdict
+    };
+}
+function dedupeFindings(findings) {
+    const seen = new Set();
+    const severityRank = { blocker: 0, high: 1, medium: 2, low: 3 };
+    return findings
+        .filter((finding) => {
+        const key = `${finding.evidence}:${finding.source}:${finding.file || ''}:${finding.line || ''}:${finding.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .sort((a, b) => a.evidence === b.evidence ? severityRank[a.severity] - severityRank[b.severity] : a.evidence === 'machine' ? -1 : 1);
+}
+function printReviewReport(report) {
+    ui.banner('review');
+    const ok = report.verdict === 'clean';
+    if (ok)
+        ui.ok(`clean (${report.files} files)`);
+    else
+        ui.warn(`${report.verdict} (${report.findings.length} findings across ${report.files} files)`);
+    for (const finding of report.findings.slice(0, 20)) {
+        const where = finding.file ? `${finding.file}${finding.line ? `:${finding.line}` : ''}` : finding.command || finding.source;
+        ui.kv(`${finding.evidence}/${finding.severity}`, `${where} - ${finding.message}`);
+    }
+}
+function summarizeProcessOutput(text) {
+    return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 8).join(' | ').slice(0, 900);
+}
+function singleLine(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 240);
+}
+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=review-command.js.map

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);