sneakoscope 0.9.13 → 0.9.15

package/src/core/commands/basic-cli.mjs

@@ -0,0 +1,315 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { COMMANDS } from '../../cli/command-registry.mjs';
+import { flag } from '../../cli/args.mjs';
+import { printJson, sksTextLogo } from '../../cli/output.mjs';
+import { PACKAGE_VERSION, ensureDir, exists, nowIso, projectRoot, readJson, runProcess, sksRoot, tmpdir, writeJsonAtomic } from '../fsx.mjs';
+import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, USAGE_TOPICS, routePrompt, routeReasoning, reasoningInstruction } from '../routes.mjs';
+import { initProject, normalizeInstallScope, sksCommandPrefix } from '../init.mjs';
+import { buildFeatureRegistry, validateFeatureRegistry } from '../feature-registry.mjs';
+import { hooksExplainReport } from '../../cli/feature-commands.mjs';
+import { writeSelftestRouteProof } from '../proof/selftest-proof-fixtures.mjs';
+import { createMission } from '../mission.mjs';
+
+export async function helpCommand(args = []) {
+  const topic = args[0];
+  if (topic) return usageCommand([topic]);
+  console.log(`${sksTextLogo()}\n\nUsage\n`);
+  console.log('  sks');
+  console.log('  sks help [topic]');
+  console.log('  sks commands [--json]');
+  console.log('  sks dollar-commands [--json]');
+  console.log('  sks proof show --json');
+  console.log('');
+  for (const row of commandRows().filter((entry) => entry.maturity !== 'labs')) {
+    console.log(`  ${row.usage.padEnd(58)} ${row.description}`);
+  }
+  console.log('\nThree core promises: Completion Proof for serious routes, Image Voxel TriWiki for visual routes, and release-gated Codex App/codex-lb/hooks/Rust evidence.');
+}
+
+export function commandsCommand(args = []) {
+  const commands = commandRows();
+  if (flag(args, '--json')) {
+    return printJson({
+      schema: 'sks.command-registry.v1',
+      aliases: ['sks', 'sneakoscope'],
+      commands
+    });
+  }
+  console.log(`${sksTextLogo()}\n\nCommands\n`);
+  const width = Math.max(...commands.map((entry) => entry.usage.length));
+  for (const entry of commands) console.log(`${entry.usage.padEnd(width)}  ${entry.description}`);
+}
+
+export function dollarCommandsCommand(args = []) {
+  const out = { dollar_commands: DOLLAR_COMMANDS, app_skill_aliases: DOLLAR_COMMAND_ALIASES };
+  if (flag(args, '--json')) return printJson(out);
+  console.log(`${sksTextLogo()}\n\n$ Commands\n`);
+  const width = Math.max(...DOLLAR_COMMANDS.map((entry) => entry.command.length));
+  for (const entry of DOLLAR_COMMANDS) console.log(`${entry.command.padEnd(width)}  ${entry.route}: ${entry.description}`);
+  console.log(`\nCanonical Codex App picker skills: ${DOLLAR_COMMAND_ALIASES.map((entry) => entry.app_skill).join(', ')}`);
+}
+
+export function aliasesCommand() {
+  console.log('Aliases');
+  console.log('- sks, sneakoscope');
+  console.log('- $ aliases:');
+  for (const entry of DOLLAR_COMMAND_ALIASES) console.log(`  ${entry.app_skill} -> ${entry.canonical}`);
+}
+
+export function dfixCommand() {
+  console.log(`SKS Direct Fix Mode
+
+Prompt command:
+  $DFix <tiny direct fix request>
+
+Rules:
+  Apply only the requested tiny copy/config/docs/labels/spacing/translation/simple mechanical edit.
+  Keep verification cheap and explicit.
+  Finish with a DFix completion summary and one Honest check line.`);
+}
+
+export function usageCommand(args = []) {
+  const topic = args[0] || 'overview';
+  if (topic === 'overview') {
+    console.log(`Usage topics: ${USAGE_TOPICS}`);
+    console.log('Try: sks usage goal, sks usage team, sks usage image-ux-review');
+    return;
+  }
+  const row = commandRows().find((entry) => entry.name === topic);
+  if (row) {
+    console.log(`${row.name}\n`);
+    console.log(`Usage: ${row.usage}`);
+    console.log(row.description);
+    return;
+  }
+  const route = DOLLAR_COMMANDS.find((entry) => entry.command.toLowerCase() === `$${topic}`.toLowerCase());
+  if (route) {
+    console.log(`${route.command}\n`);
+    console.log(`${route.route}: ${route.description}`);
+    return;
+  }
+  console.log(`Unknown usage topic: ${topic}`);
+  console.log(`Known topics: ${USAGE_TOPICS}`);
+}
+
+export function quickstartCommand() {
+  console.log(`Sneakoscope Codex Quickstart
+
+  sks setup --local-only
+  sks doctor
+  sks commands
+  sks dollar-commands
+  sks all-features selftest --mock --execute-fixtures --strict-artifacts --json
+
+For implementation work, use Codex App prompt routes such as $Team, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
+}
+
+export async function updateCheckCommand(args = []) {
+  const latest = await npmViewVersion('sneakoscope');
+  const result = {
+    package: 'sneakoscope',
+    current: PACKAGE_VERSION,
+    runtime_current: PACKAGE_VERSION,
+    latest: latest.version,
+    update_available: latest.version ? compareVersions(latest.version, PACKAGE_VERSION) > 0 : false,
+    error: latest.error || null
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log(`${sksTextLogo()}\n\nUpdate Check`);
+  console.log(`Current: ${result.current}`);
+  console.log(`Latest:  ${result.latest || 'unknown'}`);
+  console.log(`Update:  ${result.update_available ? 'available' : 'not needed'}`);
+  if (result.error) console.log(`Error:   ${result.error}`);
+  if (result.update_available) console.log(`Run:     npm i -g sneakoscope@${result.latest}`);
+}
+
+export async function setupCommand(args = []) {
+  const root = await projectRoot();
+  const installScope = installScopeFromArgs(args);
+  const res = await initProject(root, {
+    force: flag(args, '--force'),
+    installScope,
+    localOnly: flag(args, '--local-only'),
+    globalCommand: 'sks'
+  });
+  const result = {
+    schema: 'sks.setup.v1',
+    ok: true,
+    root,
+    install_scope: installScope,
+    command_prefix: sksCommandPrefix(installScope, { globalCommand: 'sks' }),
+    created: res.created || [],
+    local_only: flag(args, '--local-only')
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log(`Setup complete: ${root}`);
+  console.log(`Install scope: ${installScope}`);
+  for (const file of result.created) console.log(`- ${file}`);
+}
+
+export async function bootstrapCommand(args = []) {
+  return setupCommand(['--local-only', ...args]);
+}
+
+export async function initCommand(args = []) {
+  return setupCommand(args);
+}
+
+export async function fixPathCommand(args = []) {
+  const root = await projectRoot();
+  const installScope = installScopeFromArgs(args);
+  await initProject(root, { installScope, localOnly: flag(args, '--local-only'), globalCommand: 'sks', force: true });
+  const result = {
+    schema: 'sks.fix-path.v1',
+    ok: true,
+    root,
+    install_scope: installScope,
+    hook_command_prefix: sksCommandPrefix(installScope, { globalCommand: 'sks' }),
+    hooks: path.join(root, '.codex', 'hooks.json')
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log(`SKS hook path refreshed: ${path.relative(root, result.hooks)}`);
+}
+
+export async function depsCommand(sub = 'check', args = []) {
+  const action = sub || 'check';
+  if (action !== 'check' && action !== 'status') {
+    console.error('Usage: sks deps check [--json]');
+    process.exitCode = 1;
+    return;
+  }
+  const npm = whichSync('npm');
+  const nodeOk = Number(process.versions.node.split('.')[0]) >= 20;
+  const root = await sksRoot();
+  const result = {
+    schema: 'sks.deps-status.v1',
+    root,
+    ready: Boolean(nodeOk && npm),
+    node: { ok: nodeOk, version: process.version },
+    npm: { ok: Boolean(npm), bin: npm },
+    next_actions: [
+      ...(!nodeOk ? ['Install Node.js 20.11+.'] : []),
+      ...(!npm ? ['Install npm or a Node.js distribution that includes npm.'] : [])
+    ]
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log('SKS Dependencies');
+  console.log(`Node: ${result.node.ok ? 'ok' : 'missing'} ${result.node.version}`);
+  console.log(`npm:  ${result.npm.ok ? 'ok' : 'missing'} ${result.npm.bin || ''}`.trim());
+  if (!result.ready) process.exitCode = 1;
+}
+
+export async function postinstallCommand(args = []) {
+  const { postinstall } = await import('../../cli/install-helpers.mjs');
+  return postinstall({ bootstrap: bootstrapCommand });
+}
+
+export async function selftestCommand(args = []) {
+  process.env.CI = 'true';
+  const root = await projectRoot();
+  const tmp = tmpdir();
+  await ensureDir(tmp);
+  const registry = await buildFeatureRegistry({ root });
+  const coverage = validateFeatureRegistry(registry);
+  if (!coverage.ok) throw new Error(`selftest: feature registry blocked: ${coverage.blockers.join(', ')}`);
+  const mission = await createMission(tmp, { mode: 'team', prompt: 'selftest route proof fixture' });
+  await writeSelftestRouteProof(tmp, { missionId: mission.id, kind: 'team_gate' });
+  const proof = await readJson(path.join(tmp, '.sneakoscope', 'missions', mission.id, 'completion-proof.json'), null);
+  if (!proof?.mission_id) throw new Error('selftest: completion proof fixture missing');
+  const hookExplain = hooksExplainReport();
+  if (!hookExplain.events.includes('Stop')) throw new Error('selftest: hook explain missing Stop');
+  const result = {
+    schema: 'sks.selftest.v1',
+    ok: true,
+    version: PACKAGE_VERSION,
+    generated_at: nowIso(),
+    checks: ['feature_registry', 'route_completion_proof_fixture', 'hooks_policy_surface'],
+    tmp_root: tmp
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log('SKS selftest passed');
+}
+
+export async function reasoningCommand(args = []) {
+  const prompt = args.filter((arg) => !String(arg).startsWith('--')).join(' ').trim();
+  const route = routePrompt(prompt || '$SKS');
+  const info = routeReasoning(route, prompt);
+  const result = {
+    route: route?.command || '$SKS',
+    effort: info.effort,
+    profile: info.profile,
+    reason: info.reason,
+    temporary: true,
+    instruction: reasoningInstruction(info)
+  };
+  if (flag(args, '--json')) return printJson(result);
+  console.log('SKS Reasoning Route');
+  console.log(`Route:   ${result.route}`);
+  console.log(`Effort:  ${result.effort}`);
+  console.log(`Profile: ${result.profile}`);
+}
+
+export async function tmuxCommand(sub = 'check', args = []) {
+  const { runTmuxStatus, tmuxReadiness } = await import('../tmux-ui.mjs');
+  const action = sub || 'check';
+  if (action === 'status' || action === 'banner') return runTmuxStatus(action === 'banner' ? ['--once', ...args] : args);
+  const status = await tmuxReadiness().catch((err) => ({ ok: false, error: err.message }));
+  if (flag(args, '--json')) return printJson({ schema: 'sks.tmux-status.v1', ...status });
+  console.log(`tmux: ${status.ok ? 'ok' : 'missing'} ${status.version || status.error || ''}`.trim());
+  if (!status.ok) process.exitCode = 1;
+}
+
+export async function autoReviewCommand(sub = 'status', args = []) {
+  const { autoReviewStatus, enableAutoReview, disableAutoReview } = await import('../auto-review.mjs');
+  const action = sub || 'status';
+  const result = action === 'enable' || action === 'start'
+    ? await enableAutoReview({ high: flag(args, '--high') })
+    : action === 'disable'
+      ? await disableAutoReview()
+      : await autoReviewStatus();
+  if (flag(args, '--json')) return printJson(result);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+function commandRows() {
+  const registry = new Map(Object.entries(COMMANDS).map(([name, meta]) => [name, meta]));
+  return COMMAND_CATALOG.map((entry) => ({
+    name: entry.name,
+    usage: entry.usage,
+    description: entry.description,
+    maturity: registry.get(entry.name)?.maturity || entry.maturity || 'labs'
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function installScopeFromArgs(args = [], fallback = 'global') {
+  if (flag(args, '--project')) return 'project';
+  if (flag(args, '--global')) return 'global';
+  const index = args.indexOf('--install-scope');
+  return normalizeInstallScope(index >= 0 && args[index + 1] ? args[index + 1] : fallback);
+}
+
+async function npmViewVersion(name) {
+  const npm = whichSync('npm');
+  if (!npm) return { version: null, error: 'npm not found on PATH' };
+  const result = await runProcess(npm, ['view', name, 'version', '--silent'], { timeoutMs: 15000, maxOutputBytes: 4096 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  if (result.code !== 0) return { version: null, error: (result.stderr || result.stdout || 'npm view failed').trim() };
+  return { version: String(result.stdout || '').trim().split(/\s+/).pop() || null };
+}
+
+function compareVersions(a, b) {
+  const pa = String(a || '').split('.').map((x) => Number.parseInt(x, 10) || 0);
+  const pb = String(b || '').split('.').map((x) => Number.parseInt(x, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
+  }
+  return 0;
+}
+
+function whichSync(command) {
+  const result = spawnSync(process.platform === 'win32' ? 'where' : 'command', process.platform === 'win32' ? [command] : ['-v', command], {
+    encoding: 'utf8',
+    shell: process.platform !== 'win32'
+  });
+  return result.status === 0 ? String(result.stdout || '').trim().split(/\r?\n/)[0] : null;
+}

package/src/{cli/maintenance-commands.mjs → core/commands/route-cli.mjs}

@@ -1,43 +1,43 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { createHash } from 'node:crypto';
-import { readJson, readText, writeJsonAtomic, writeTextAtomic, appendJsonlBounded, nowIso, exists, ensureDir, packageRoot, dirSize, formatBytes, PACKAGE_VERSION, sksRoot, readStdin, runProcess } from '../core/fsx.mjs';
-import { initProject } from '../core/init.mjs';
-import { getCodexInfo, runCodexExec } from '../core/codex-adapter.mjs';
-import { createMission, loadMission, findLatestMission, missionDir, setCurrent, stateFile } from '../core/mission.mjs';
-import { buildQuestionSchema, writeQuestions } from '../core/questions.mjs';
-import { sealContract } from '../core/decision-contract.mjs';
-import { buildQaLoopQuestionSchema, buildQaLoopPrompt, evaluateQaGate, qaStatus, writeMockQaResult, writeQaLoopArtifacts } from '../core/qa-loop.mjs';
-import { containsUserQuestion, noQuestionContinuationReason } from '../core/no-question-guard.mjs';
-import { RESEARCH_GENIUS_SUMMARY_ARTIFACT, RESEARCH_SOURCE_SKILL_ARTIFACT, countGeniusOpinionSummaries, countResearchPaperSections, buildResearchPrompt, evaluateResearchGate, findResearchPaperArtifact, researchPaperArtifactForPlan, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
-import { storageReport, enforceRetention, pruneWikiArtifacts } from '../core/retention.mjs';
-import { evaluateDoneGate } from '../core/hproof.mjs';
-import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../core/gx-renderer.mjs';
-import { DEFAULT_EVAL_THRESHOLDS, compareEvaluationReports, runEvaluationBenchmark } from '../core/evaluation.mjs';
-import { contextCapsule } from '../core/triwiki-attention.mjs';
-import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../core/wiki-coordinate.mjs';
-import { ALLOWED_REASONING_EFFORTS, CODEX_COMPUTER_USE_ONLY_POLICY, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, RECOMMENDED_SKILLS, ROUTES, hasFromChatImgSignal, reflectionRequiredForRoute, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stackCurrentDocsPolicy, stripVisibleDecisionAnswerBlocks, triwikiContextTracking } from '../core/routes.mjs';
-import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
-import { appendTeamEvent, formatAgentReasoning, formatRoleCounts, initTeamLive, isTerminalTeamAgentStatus, normalizeTeamSpec, parseTeamSpecArgs, readTeamControl, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane, renderTeamCleanupSummary, renderTeamWatch, requestTeamSessionCleanup, teamCleanupRequested, teamReasoningPolicy } from '../core/team-live.mjs';
-import { evaluateTeamReviewPolicyGate, MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT, teamReviewPolicy } from '../core/team-review-policy.mjs';
-import { ARTIFACT_FILES, writeValidationReport } from '../core/artifact-schemas.mjs';
-import { writeEffortDecision } from '../core/effort-orchestrator.mjs';
-import { createWorkOrderLedger, writeWorkOrderLedger } from '../core/work-order-ledger.mjs';
-import { writeFromChatImgArtifacts } from '../core/from-chat-img-forensics.mjs';
-import { renderTeamDashboardState, writeTeamDashboardState } from '../core/team-dashboard-renderer.mjs';
-import { runPerfBench, runWorkflowPerfBench } from '../core/perf-bench.mjs';
-import { writeProofFieldReport } from '../core/proof-field.mjs';
-import { PIPELINE_PLAN_ARTIFACT, validatePipelinePlan, writePipelinePlan } from '../core/pipeline.mjs';
-import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../core/goal-workflow.mjs';
-import { scanCodeStructure, writeCodeStructureReport } from '../core/code-structure.mjs';
-import { writeMemorySweepReport } from '../core/memory-governor.mjs';
-import { cleanupTmuxTeamView, defaultTmuxSessionName, launchMadTmuxUi, launchTmuxTeamView, reconcileTmuxTeamCockpit, sanitizeTmuxSessionName } from '../core/tmux-ui.mjs';
-import { loadSkillDreamState, recordSkillDreamEvent, runSkillDream, writeSkillForgeReport } from '../core/skill-forge.mjs';
-import { writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
-import { checkDbOperation, checkSqlFile, classifyCommand, classifySql, loadDbSafetyPolicy, safeSupabaseMcpConfig, scanDbSafety } from '../core/db-safety.mjs';
-import { harnessGrowthReport, writeHarnessGrowthReport } from '../core/evaluation.mjs';
-import { enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
-import { permissionGateSummary } from '../core/permission-gates.mjs';
+import { readJson, readText, writeJsonAtomic, writeTextAtomic, appendJsonlBounded, nowIso, exists, ensureDir, packageRoot, dirSize, formatBytes, PACKAGE_VERSION, sksRoot, readStdin, runProcess } from '../fsx.mjs';
+import { initProject } from '../init.mjs';
+import { getCodexInfo, runCodexExec } from '../codex-adapter.mjs';
+import { createMission, loadMission, findLatestMission, missionDir, setCurrent, stateFile } from '../mission.mjs';
+import { buildQuestionSchema, writeQuestions } from '../questions.mjs';
+import { sealContract } from '../decision-contract.mjs';
+import { buildQaLoopQuestionSchema, buildQaLoopPrompt, evaluateQaGate, qaStatus, writeMockQaResult, writeQaLoopArtifacts } from '../qa-loop.mjs';
+import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.mjs';
+import { RESEARCH_GENIUS_SUMMARY_ARTIFACT, RESEARCH_SOURCE_SKILL_ARTIFACT, countGeniusOpinionSummaries, countResearchPaperSections, buildResearchPrompt, evaluateResearchGate, findResearchPaperArtifact, researchPaperArtifactForPlan, writeMockResearchResult, writeResearchPlan } from '../research.mjs';
+import { storageReport, enforceRetention, pruneWikiArtifacts } from '../retention.mjs';
+import { evaluateDoneGate } from '../hproof.mjs';
+import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../gx-renderer.mjs';
+import { DEFAULT_EVAL_THRESHOLDS, compareEvaluationReports, runEvaluationBenchmark } from '../evaluation.mjs';
+import { contextCapsule } from '../triwiki-attention.mjs';
+import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../wiki-coordinate.mjs';
+import { ALLOWED_REASONING_EFFORTS, CODEX_COMPUTER_USE_ONLY_POLICY, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, RECOMMENDED_SKILLS, ROUTES, hasFromChatImgSignal, reflectionRequiredForRoute, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stackCurrentDocsPolicy, stripVisibleDecisionAnswerBlocks, triwikiContextTracking } from '../routes.mjs';
+import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../team-dag.mjs';
+import { appendTeamEvent, formatAgentReasoning, formatRoleCounts, initTeamLive, isTerminalTeamAgentStatus, normalizeTeamSpec, parseTeamSpecArgs, readTeamControl, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane, renderTeamCleanupSummary, renderTeamWatch, requestTeamSessionCleanup, teamCleanupRequested, teamReasoningPolicy } from '../team-live.mjs';
+import { evaluateTeamReviewPolicyGate, MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT, teamReviewPolicy } from '../team-review-policy.mjs';
+import { ARTIFACT_FILES, writeValidationReport } from '../artifact-schemas.mjs';
+import { writeEffortDecision } from '../effort-orchestrator.mjs';
+import { createWorkOrderLedger, writeWorkOrderLedger } from '../work-order-ledger.mjs';
+import { writeFromChatImgArtifacts } from '../from-chat-img-forensics.mjs';
+import { renderTeamDashboardState, writeTeamDashboardState } from '../team-dashboard-renderer.mjs';
+import { runPerfBench, runWorkflowPerfBench } from '../perf-bench.mjs';
+import { writeProofFieldReport } from '../proof-field.mjs';
+import { PIPELINE_PLAN_ARTIFACT, validatePipelinePlan, writePipelinePlan } from '../pipeline.mjs';
+import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../goal-workflow.mjs';
+import { scanCodeStructure, writeCodeStructureReport } from '../code-structure.mjs';
+import { writeMemorySweepReport } from '../memory-governor.mjs';
+import { cleanupTmuxTeamView, defaultTmuxSessionName, launchMadTmuxUi, launchTmuxTeamView, reconcileTmuxTeamCockpit, sanitizeTmuxSessionName } from '../tmux-ui.mjs';
+import { loadSkillDreamState, recordSkillDreamEvent, runSkillDream, writeSkillForgeReport } from '../skill-forge.mjs';
+import { writeMistakeMemoryReport } from '../mistake-memory.mjs';
+import { checkDbOperation, checkSqlFile, classifyCommand, classifySql, loadDbSafetyPolicy, safeSupabaseMcpConfig, scanDbSafety } from '../db-safety.mjs';
+import { harnessGrowthReport, writeHarnessGrowthReport } from '../evaluation.mjs';
+import { enableMadHighProfile, madHighProfileName } from '../auto-review.mjs';
+import { permissionGateSummary } from '../permission-gates.mjs';
 
 const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();

package/src/core/feature-fixture-runner.mjs

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export function runFeatureFixture(feature, {
+  root = process.cwd(),
+  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-feature-fixture-')),
+  execute = false,
+  validateArtifacts = false,
+  commandArgs = null
+} = {}) {
+  const fixture = feature.fixture || {};
+  const expected = Array.isArray(fixture.expected_artifacts) ? fixture.expected_artifacts : [];
+  const artifacts = expected.map((artifact) => materializeExpectedArtifact(tempRoot, artifact));
+  const execution = execute && commandArgs
+    ? executeCommand(root, commandArgs)
+    : null;
+  const artifactFailures = validateArtifacts
+    ? artifacts.filter((artifact) => !artifact.exists || !artifact.schema_ok).map((artifact) => `${feature.id}:${artifact.path}`)
+    : [];
+  return {
+    id: feature.id,
+    kind: fixture.kind || 'static',
+    command: fixture.command || null,
+    temp_root: tempRoot,
+    executed: Boolean(execution),
+    execution,
+    expected_artifacts: artifacts,
+    artifact_schema_validated: validateArtifacts,
+    ok: (!execution || execution.ok) && artifactFailures.length === 0,
+    failures: [
+      ...(!fixture.command && fixture.status === 'pass' ? [`${feature.id}:fixture_command_missing`] : []),
+      ...(execution && !execution.ok ? [`${feature.id}:command_exit_${execution.status}`] : []),
+      ...artifactFailures
+    ]
+  };
+}
+
+export function writeFeatureFixtureReports(root, report) {
+  const reportDir = path.join(root, '.sneakoscope', 'reports');
+  fs.mkdirSync(reportDir, { recursive: true });
+  const jsonPath = path.join(reportDir, 'feature-fixtures.json');
+  const mdPath = path.join(reportDir, 'feature-fixtures.md');
+  fs.writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
+  fs.writeFileSync(mdPath, renderFeatureFixtureMarkdown(report));
+  return { json: jsonPath, md: mdPath };
+}
+
+function executeCommand(root, args = []) {
+  const result = spawnSync(process.execPath, [path.join(root, 'bin', 'sks.mjs'), ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 15_000,
+    env: { ...process.env, CI: 'true', SKS_SKIP_NPM_FRESHNESS_CHECK: '1' }
+  });
+  return {
+    args,
+    status: result.status,
+    signal: result.signal || null,
+    ok: result.status === 0,
+    stdout_bytes: Buffer.byteLength(result.stdout || ''),
+    stderr_bytes: Buffer.byteLength(result.stderr || '')
+  };
+}
+
+function materializeExpectedArtifact(tempRoot, artifact) {
+  const rel = typeof artifact === 'string' ? artifact : artifact.path;
+  const schema = typeof artifact === 'object' ? artifact.schema : inferSchema(rel);
+  const normalized = String(rel || '').replace('<latest>', 'M-fixture');
+  const file = path.join(tempRoot, normalized);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const body = normalized.endsWith('.md')
+    ? `# Fixture Artifact\n\nSchema: ${schema || 'text'}\n`
+    : JSON.stringify({ schema: schema || inferSchema(normalized), ok: true, fixture: true }, null, 2) + '\n';
+  fs.writeFileSync(file, body);
+  return {
+    path: normalized,
+    schema: schema || inferSchema(normalized),
+    exists: fs.existsSync(file),
+    schema_ok: normalized.endsWith('.md') || Boolean(JSON.parse(fs.readFileSync(file, 'utf8')).schema)
+  };
+}
+
+function inferSchema(file = '') {
+  if (file.includes('completion-proof')) return 'sks.completion-proof.v1';
+  if (file.includes('image-voxel-ledger')) return 'sks.image-voxel-ledger.v1';
+  if (file.includes('visual-anchors')) return 'sks.visual-anchors.v1';
+  if (file.includes('image-assets')) return 'sks.image-assets.v1';
+  if (file.endsWith('.json')) return 'sks.fixture-artifact.v1';
+  return null;
+}
+
+function renderFeatureFixtureMarkdown(report = {}) {
+  const lines = [
+    '# SKS Feature Fixtures',
+    '',
+    `- Status: ${report.ok ? 'pass' : 'blocked'}`,
+    `- Checked: ${report.checked || 0}`,
+    `- Executed: ${report.executed || 0}`,
+    `- Artifact/schema validated: ${report.artifact_schema_validated || 0}`,
+    ''
+  ];
+  if (report.failures?.length) {
+    lines.push('## Failures', '');
+    for (const failure of report.failures) lines.push(`- ${failure}`);
+  }
+  return `${lines.join('\n')}\n`;
+}

package/src/core/feature-fixtures.mjs

@@ -63,7 +63,7 @@ const FIXTURES = Object.freeze({
 });
 
 export function fixtureForFeature(featureId) {
-  return FIXTURES[featureId] || fixture('static', null, [], 'not_required');
+  return FIXTURES[featureId] || fixture('static', 'sks features check --json', [], 'pass');
 }
 
 export function fixtureSummary(features = []) {

package/src/core/feature-registry.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS } from './routes.mjs';
 import { fixtureForFeature, fixtureSummary, validateFeatureFixtures } from './feature-fixtures.mjs';
+import { runFeatureFixture, writeFeatureFixtureReports } from './feature-fixture-runner.mjs';
 import { exists, nowIso, packageRoot, readJson, readText, runProcess, writeTextAtomic } from './fsx.mjs';
 
 export const FEATURE_REGISTRY_SCHEMA = 'sks.feature-registry.v1';
@@ -148,7 +149,8 @@ export function buildAllFeaturesSelftest(registry, opts = {}) {
     checkRow('fixture_contracts_present', fixtures.ok, fixtures.blockers),
     checkRow('proof_fixture_contract_present', registry.features.some((feature) => feature.id === 'cli-proof' && feature.fixture?.status === 'pass'), ['cli-proof']),
     checkRow('voxel_fixture_contract_present', registry.features.some((feature) => feature.id === 'cli-wiki' && feature.fixture?.expected_artifacts?.some((artifact) => artifact.includes('image-voxel-ledger'))), ['cli-wiki']),
-    checkRow('fixture_pass_threshold', (fixturesSummary.counts.pass || 0) >= 45, [`pass=${fixturesSummary.counts.pass || 0}`]),
+    checkRow('fixture_pass_threshold', (fixturesSummary.counts.pass || 0) >= 90, [`pass=${fixturesSummary.counts.pass || 0}`]),
+    checkRow('fixture_not_required_ceiling', (fixturesSummary.counts.not_required || 0) <= 16, [`not_required=${fixturesSummary.counts.not_required || 0}`]),
     checkRow('fixture_mock_blocked_zero', (fixturesSummary.counts.blocked || 0) === 0, [`blocked=${fixturesSummary.counts.blocked || 0}`]),
     ...(executable ? [checkRow('executable_fixture_contracts', executable.ok, executable.failures)] : [])
   ];
@@ -173,6 +175,7 @@ export function executeFeatureFixtures(features = [], opts = {}) {
   const failures = [];
   const checked = [];
   const executed = [];
+  let artifactValidated = 0;
   for (const feature of selected) {
     const fx = feature.fixture;
     if (!fx.command) {
@@ -186,25 +189,37 @@ export function executeFeatureFixtures(features = [], opts = {}) {
       executed.push(execution);
       if (!execution.ok) failures.push(`${feature.id}:command_exit_${execution.status}`);
     }
+    const strict = opts.strictArtifacts || opts.validateArtifacts;
+    const artifactRun = runFeatureFixture(feature, {
+      root: opts.root || packageRoot(),
+      execute: false,
+      validateArtifacts: strict,
+      commandArgs: SAFE_EXECUTABLE_FIXTURE_ARGS[feature.id] || null
+    });
+    if (strict) artifactValidated += artifactRun.expected_artifacts.length;
+    failures.push(...artifactRun.failures.filter((failure) => !failures.includes(failure)));
     checked.push({
       id: feature.id,
       kind: fx.kind,
       command: fx.command,
       expected_artifacts: fx.expected_artifacts,
-      mode: execution ? 'command_and_contract' : 'contract'
+      mode: execution ? 'command_and_contract' : strict ? 'strict_artifact_schema' : 'contract'
     });
   }
-  return {
+  const report = {
     schema: 'sks.feature-fixture-execution.v1',
     mode: 'mock',
     ok: failures.length === 0,
     checked: checked.length,
     executed: executed.length,
+    artifact_schema_validated: artifactValidated,
     executed_commands: executed,
     failures,
     command_execution: executed.length ? 'safe-allowlist' : 'contract-only',
     note: 'Release fixture execution runs deterministic safe CLI fixtures and validates mock/static contracts without claiming real external dependency runs.'
   };
+  if (opts.root) report.report_files = writeFeatureFixtureReports(opts.root, report);
+  return report;
 }
 
 function executeSafeFixtureCommand(featureId, opts = {}) {
@@ -422,10 +437,7 @@ async function parseMainHandlerKeys(root) {
   const registryText = await readText(path.join(root, 'src', 'cli', 'command-registry.mjs'), '');
   const registryMatch = registryText.match(/export const COMMANDS = \{([\s\S]*?)\n\};/);
   if (registryMatch) return parseObjectKeys(registryMatch[1]);
-  const text = await readText(path.join(root, 'src', 'cli', 'legacy-main.mjs'), '');
-  const match = text.match(/const handlers = \{([\s\S]*?)\n\s*\};/);
-  if (!match) return [];
-  return parseObjectKeys(match[1]);
+  return [];
 }
 
 function parseObjectKeys(text = '') {

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.9.13';
+export const PACKAGE_VERSION = '0.9.15';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;