@vyuhlabs/dxkit 2.22.0 → 2.24.0

package/dist/analyzers/correctness/surface.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The correctness-floor SURFACE resolver — decides, per surface, whether the
+ * floor runs by default. This is the canonical resolver for the correctness
+ * capability (mirror of `resolveBaselineMode` for baseline modes, Rule 11): one
+ * function, one precedence order, so no two call sites drift on the default.
+ *
+ * Three surfaces run the floor, with different postures:
+ *   - `loop-stop`  — an autonomous loop's Stop-gate. ALWAYS default-on: an agent
+ *     must never declare "done" on code that does not compile or whose tests
+ *     fail. (An explicit flag/policy can still turn it off, but the default is
+ *     on regardless of what CI the repo has.)
+ *   - `pre-push` / `ci` — ADAPTIVE. If the repo already runs its tests in its own
+ *     CI, dxkit's floor is redundant there, so it defaults to OPT-IN. If no
+ *     test-running CI is detected, the floor defaults ON so pushes/PRs are still
+ *     checked. When we cannot tell (a CI exists but its test step is opaque), we
+ *     FAIL TOWARD ON — a redundant floor run is cheap; a missed regression is not.
+ *
+ * Precedence (highest first), mirroring the loop-preset + baseline-mode
+ * resolvers:
+ *   1. explicit `flag` argument (a `--correctness` / `--no-correctness` CLI flag)
+ *   2. `DXKIT_FLOOR_<SURFACE>` env var (benchmark / CI override)
+ *   3. `.dxkit/policy.json` → `correctness.surfaces.<surface>`
+ *   4. the surface's default (always-on for loop-stop; adaptive for pre-push/ci)
+ */
+export type CorrectnessSurface = 'loop-stop' | 'pre-push' | 'ci';
+export type SurfaceDecisionSource = 'always-on' | 'flag' | 'env' | 'policy' | 'adaptive-no-test-ci' | 'adaptive-test-ci-detected' | 'adaptive-uncertain';
+export interface SurfaceResolution {
+    readonly surface: CorrectnessSurface;
+    readonly enabled: boolean;
+    readonly source: SurfaceDecisionSource;
+    /** One-line human-readable rationale, for `doctor` / CLI output. */
+    readonly reason: string;
+}
+export type TestCiStatus = 'has-test-ci' | 'no-test-ci' | 'uncertain';
+export interface TestCiDetection {
+    readonly status: TestCiStatus;
+    /** When `has-test-ci`, the file + command that proved it (for the reason). */
+    readonly evidence?: string;
+}
+/**
+ * Detect whether the repo runs its tests in its OWN CI. Reads GitHub Actions
+ * workflows (excluding dxkit-authored ones) plus the common flat CI configs,
+ * scanning for a test invocation:
+ *   - a matching test command in any file → `has-test-ci`;
+ *   - no CI config found at all → `no-test-ci` (dxkit's floor should default on);
+ *   - CI config exists but no test command matched (opaque `make ci`, a called
+ *     reusable workflow, etc.) → `uncertain` (fail toward on).
+ * Best-effort and never throws — an unreadable file is skipped.
+ */
+export declare function detectTestCi(cwd: string): TestCiDetection;
+/** Read `correctness.surfaces.<surface>` from `.dxkit/policy.json`. Best-effort:
+ *  a missing / malformed file or absent block yields an empty map. */
+export declare function readSurfacePolicy(cwd: string): Partial<Record<CorrectnessSurface, boolean>>;
+export interface ResolveSurfaceOptions {
+    readonly surface: CorrectnessSurface;
+    readonly cwd: string;
+    /** Explicit `--correctness` / `--no-correctness` CLI flag (highest precedence). */
+    readonly flag?: boolean;
+    /** Injected for tests; defaults to reading `.dxkit/policy.json`. */
+    readonly policySurfaces?: Partial<Record<CorrectnessSurface, boolean>>;
+    /** Injected for tests; defaults to the real `detectTestCi`. */
+    readonly detect?: (cwd: string) => TestCiDetection;
+}
+/**
+ * Resolve whether the correctness floor is enabled on a surface. Pure aside from
+ * the default policy/env reads (both injectable); never throws.
+ */
+export declare function resolveCorrectnessSurface(opts: ResolveSurfaceOptions): SurfaceResolution;
+//# sourceMappingURL=surface.d.ts.map

package/dist/analyzers/correctness/surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../../../src/analyzers/correctness/surface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAOH,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,UAAU,GAAG,IAAI,CAAC;AAEjE,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,MAAM,GACN,KAAK,GACL,QAAQ,GACR,qBAAqB,GACrB,2BAA2B,GAC3B,oBAAoB,CAAC;AAEzB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,YAAY,GAAG,WAAW,CAAC;AAEtE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CA4CzD;AAID;sEACsE;AACtE,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC,CAgB3F;AAoBD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC,CAAC;IACvE,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,eAAe,CAAC;CACpD;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,qBAAqB,GAAG,iBAAiB,CAwExF"}

package/dist/analyzers/correctness/surface.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * The correctness-floor SURFACE resolver — decides, per surface, whether the
+ * floor runs by default. This is the canonical resolver for the correctness
+ * capability (mirror of `resolveBaselineMode` for baseline modes, Rule 11): one
+ * function, one precedence order, so no two call sites drift on the default.
+ *
+ * Three surfaces run the floor, with different postures:
+ *   - `loop-stop`  — an autonomous loop's Stop-gate. ALWAYS default-on: an agent
+ *     must never declare "done" on code that does not compile or whose tests
+ *     fail. (An explicit flag/policy can still turn it off, but the default is
+ *     on regardless of what CI the repo has.)
+ *   - `pre-push` / `ci` — ADAPTIVE. If the repo already runs its tests in its own
+ *     CI, dxkit's floor is redundant there, so it defaults to OPT-IN. If no
+ *     test-running CI is detected, the floor defaults ON so pushes/PRs are still
+ *     checked. When we cannot tell (a CI exists but its test step is opaque), we
+ *     FAIL TOWARD ON — a redundant floor run is cheap; a missed regression is not.
+ *
+ * Precedence (highest first), mirroring the loop-preset + baseline-mode
+ * resolvers:
+ *   1. explicit `flag` argument (a `--correctness` / `--no-correctness` CLI flag)
+ *   2. `DXKIT_FLOOR_<SURFACE>` env var (benchmark / CI override)
+ *   3. `.dxkit/policy.json` → `correctness.surfaces.<surface>`
+ *   4. the surface's default (always-on for loop-stop; adaptive for pre-push/ci)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTestCi = detectTestCi;
+exports.readSurfacePolicy = readSurfacePolicy;
+exports.resolveCorrectnessSurface = resolveCorrectnessSurface;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const policy_1 = require("../../baseline/policy");
+// ─── Test-CI detection ──────────────────────────────────────────────────────
+/** CI config files we can read as text and scan for a test invocation. Ordered
+ *  by ubiquity; GitHub Actions workflows are handled separately (a directory). */
+const FLAT_CI_FILES = [
+    '.gitlab-ci.yml',
+    '.gitlab-ci.yaml',
+    'Jenkinsfile',
+    '.circleci/config.yml',
+    'azure-pipelines.yml',
+    'azure-pipelines.yaml',
+    '.travis.yml',
+    'bitbucket-pipelines.yml',
+];
+/** Substrings that mark a real test invocation, unioned across ecosystems. Kept
+ *  deliberately specific (a bare "test" would match too much) so a match is a
+ *  confident "this CI runs tests" signal. */
+const TEST_COMMAND_PATTERNS = [
+    /\bnpm (run )?test\b/,
+    /\byarn (run )?test\b/,
+    /\bpnpm (run )?test\b/,
+    /\bnpx (vitest|jest|mocha|ava|playwright)\b/,
+    /\b(vitest|jest|mocha|ava)\b/,
+    /\bpytest\b/,
+    /\bpython -m (pytest|unittest)\b/,
+    /\b(tox|nox)\b/,
+    /\bgo test\b/,
+    /\bcargo (test|nextest)\b/,
+    /\bmvn (.*\s)?(test|verify)\b/,
+    /\b(\.\/)?gradlew? (.*\s)?(test|check)\b/,
+    /\bdotnet test\b/,
+    /\b(bundle exec )?rspec\b/,
+    /\brake (.*\s)?test\b/,
+    /\bmake (.*\s)?test\b/,
+    /\bjust (.*\s)?test\b/,
+];
+/** Is a workflow file one dxkit itself installed? Its own guardrail/floor CI is
+ *  the surface being resolved, not a pre-existing test-CI, so it must not count
+ *  as the repo "already testing in CI". */
+function isDxkitAuthoredWorkflow(name) {
+    return name.startsWith('dxkit-');
+}
+function textRunsTests(text) {
+    return TEST_COMMAND_PATTERNS.some((re) => re.test(text));
+}
+function matchedTestCommand(text) {
+    for (const re of TEST_COMMAND_PATTERNS) {
+        const m = re.exec(text);
+        if (m)
+            return m[0];
+    }
+    return undefined;
+}
+/**
+ * Detect whether the repo runs its tests in its OWN CI. Reads GitHub Actions
+ * workflows (excluding dxkit-authored ones) plus the common flat CI configs,
+ * scanning for a test invocation:
+ *   - a matching test command in any file → `has-test-ci`;
+ *   - no CI config found at all → `no-test-ci` (dxkit's floor should default on);
+ *   - CI config exists but no test command matched (opaque `make ci`, a called
+ *     reusable workflow, etc.) → `uncertain` (fail toward on).
+ * Best-effort and never throws — an unreadable file is skipped.
+ */
+function detectTestCi(cwd) {
+    let sawAnyCi = false;
+    // GitHub Actions workflows (a directory of yml/yaml files).
+    const wfDir = path.join(cwd, '.github', 'workflows');
+    let wfNames = [];
+    try {
+        wfNames = fs
+            .readdirSync(wfDir)
+            .filter((n) => (n.endsWith('.yml') || n.endsWith('.yaml')) && !isDxkitAuthoredWorkflow(n));
+    }
+    catch {
+        /* no workflows dir */
+    }
+    for (const name of wfNames) {
+        sawAnyCi = true;
+        let text;
+        try {
+            text = fs.readFileSync(path.join(wfDir, name), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (textRunsTests(text)) {
+            return {
+                status: 'has-test-ci',
+                evidence: `.github/workflows/${name}: ${matchedTestCommand(text)}`,
+            };
+        }
+    }
+    // Flat CI config files.
+    for (const rel of FLAT_CI_FILES) {
+        let text;
+        try {
+            text = fs.readFileSync(path.join(cwd, rel), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        sawAnyCi = true;
+        if (textRunsTests(text)) {
+            return { status: 'has-test-ci', evidence: `${rel}: ${matchedTestCommand(text)}` };
+        }
+    }
+    return sawAnyCi ? { status: 'uncertain' } : { status: 'no-test-ci' };
+}
+// ─── Policy + env reads ─────────────────────────────────────────────────────
+/** Read `correctness.surfaces.<surface>` from `.dxkit/policy.json`. Best-effort:
+ *  a missing / malformed file or absent block yields an empty map. */
+function readSurfacePolicy(cwd) {
+    try {
+        const raw = fs.readFileSync(path.join(cwd, policy_1.DEFAULT_POLICY_FILENAME), 'utf8');
+        const parsed = JSON.parse(raw);
+        const surfaces = parsed.correctness?.surfaces;
+        if (!surfaces || typeof surfaces !== 'object')
+            return {};
+        const out = {};
+        for (const s of ['loop-stop', 'pre-push', 'ci']) {
+            if (typeof surfaces[s] === 'boolean')
+                out[s] = surfaces[s];
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+const ENV_VAR = {
+    'loop-stop': 'DXKIT_FLOOR_LOOP',
+    'pre-push': 'DXKIT_FLOOR_PREPUSH',
+    ci: 'DXKIT_FLOOR_CI',
+};
+/** Parse a truthy/falsy env override, or undefined when unset/unrecognized. */
+function envOverride(surface) {
+    const raw = process.env[ENV_VAR[surface]];
+    if (raw === undefined)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (['1', 'true', 'on', 'yes'].includes(v))
+        return true;
+    if (['0', 'false', 'off', 'no'].includes(v))
+        return false;
+    return undefined;
+}
+/**
+ * Resolve whether the correctness floor is enabled on a surface. Pure aside from
+ * the default policy/env reads (both injectable); never throws.
+ */
+function resolveCorrectnessSurface(opts) {
+    const { surface } = opts;
+    // 1. explicit CLI flag
+    if (opts.flag !== undefined) {
+        return {
+            surface,
+            enabled: opts.flag,
+            source: 'flag',
+            reason: `explicitly ${opts.flag ? 'enabled' : 'disabled'} via flag`,
+        };
+    }
+    // 2. env override
+    const env = envOverride(surface);
+    if (env !== undefined) {
+        return {
+            surface,
+            enabled: env,
+            source: 'env',
+            reason: `${env ? 'enabled' : 'disabled'} via ${ENV_VAR[surface]}`,
+        };
+    }
+    // 3. policy file
+    const policy = opts.policySurfaces ?? readSurfacePolicy(opts.cwd);
+    const pol = policy[surface];
+    if (pol !== undefined) {
+        return {
+            surface,
+            enabled: pol,
+            source: 'policy',
+            reason: `${pol ? 'enabled' : 'disabled'} via .dxkit/policy.json correctness.surfaces.${surface}`,
+        };
+    }
+    // 4. surface default
+    if (surface === 'loop-stop') {
+        return {
+            surface,
+            enabled: true,
+            source: 'always-on',
+            reason: 'loop Stop-gate runs the floor by default — an agent must not stop on broken code',
+        };
+    }
+    // pre-push / ci: adaptive on the repo's own test-CI
+    const det = (opts.detect ?? detectTestCi)(opts.cwd);
+    if (det.status === 'has-test-ci') {
+        return {
+            surface,
+            enabled: false,
+            source: 'adaptive-test-ci-detected',
+            reason: `opt-in — the repo already runs tests in CI (${det.evidence}); enable explicitly to also run dxkit's floor here`,
+        };
+    }
+    if (det.status === 'no-test-ci') {
+        return {
+            surface,
+            enabled: true,
+            source: 'adaptive-no-test-ci',
+            reason: 'no test-running CI detected — the floor runs by default so changes are still checked',
+        };
+    }
+    return {
+        surface,
+        enabled: true,
+        source: 'adaptive-uncertain',
+        reason: 'a CI exists but its test step is opaque — running the floor to be safe (fail toward on)',
+    };
+}
+//# sourceMappingURL=surface.js.map

package/dist/analyzers/correctness/surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.js","sourceRoot":"","sources":["../../../src/analyzers/correctness/surface.ts"],"names":[],"mappings":"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"}

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA4SA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAo/DvD"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA4SA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAkpEvD"}

package/dist/cli.js

@@ -376,6 +376,12 @@ async function run(argv) {
             'added-by': { type: 'string' },
             mode: { type: 'string' },
             ref: { type: 'string' },
+            surface: { type: 'string' },
+            correctness: { type: 'boolean' },
+            'no-correctness': { type: 'boolean' },
+            'keep-baselines': { type: 'boolean', default: false },
+            'remove-devdep': { type: 'boolean', default: false },
+            'no-feedback': { type: 'boolean', default: false },
             'soon-days': { type: 'string' },
             'against-baseline': { type: 'boolean', default: false },
             'baseline-name': { type: 'string' },
@@ -1801,9 +1807,13 @@ async function run(argv) {
                     `Expected one of: committed-full, committed-sanitized, ref-based.`);
                 process.exit(1);
             }
-            if (!values.json)
+            // Suppress the console header/info in --json AND --markdown: both are
+            // machine-captured (piped to a file / a PR comment), so the ANSI-styled
+            // console chrome would leak into the report.
+            const quiet = !!values.json || !!values.markdown;
+            if (!quiet)
                 logger.header('vyuh-dxkit guardrail check');
-            if (!values.json)
+            if (!quiet)
                 logger.info(`Checking ${targetPath} against baseline...`);
             const startTime = Date.now();
             try {
@@ -1819,7 +1829,7 @@ async function run(argv) {
                     cliMode: cliMode ?? undefined,
                     cliRef: values.ref,
                 });
-                if (!values.json)
+                if (!quiet)
                     logger.info(`Baseline ${result.mode.explanation}`);
                 const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                 if (values.json) {
@@ -1840,6 +1850,118 @@ async function run(argv) {
             }
             break;
         }
+        case 'uninstall': {
+            const targetPath = resolveRepoPath(positionals[1]);
+            const { planUninstall, executeUninstall } = await Promise.resolve().then(() => __importStar(require('./uninstall')));
+            const opts = {
+                keepBaselines: !!values['keep-baselines'],
+                removeDevDependency: !!values['remove-devdep'],
+                force: !!values.force,
+            };
+            const plan = planUninstall(targetPath, opts);
+            if (values.json) {
+                await emitJson({ empty: plan.empty, warnings: plan.warnings, actions: plan.actions });
+                process.exit(0);
+            }
+            logger.header('vyuh-dxkit uninstall');
+            if (plan.empty) {
+                logger.info('No dxkit footprint found in this repo — nothing to remove.');
+                process.exit(0);
+            }
+            const active = plan.actions.filter((a) => a.status === 'pending');
+            logger.info(`Will restore the pre-dxkit state by ${active.length} change(s):`);
+            for (const a of active) {
+                const verb = a.kind.startsWith('revert')
+                    ? 'revert'
+                    : a.kind === 'git-config-unset'
+                        ? 'unset'
+                        : 'remove';
+                process.stdout.write(`  ${verb.padEnd(6)} ${a.target}  (${a.detail})\n`);
+            }
+            for (const w of plan.warnings)
+                logger.warn(w);
+            if (!opts.removeDevDependency) {
+                logger.dim('  (package.json @vyuhlabs/dxkit devDependency kept — pass --remove-devdep to remove it)');
+            }
+            if (!values.yes) {
+                logger.info('');
+                logger.info(`Dry run — nothing changed. Re-run with ${(0, self_invocation_1.dxkitCli)('uninstall --yes')} to apply.`);
+                process.exit(0);
+            }
+            const result = executeUninstall(targetPath, plan, opts);
+            logger.success(`Removed ${result.removed.length}, reverted ${result.reverted.length}` +
+                (result.skipped.length
+                    ? `, skipped ${result.skipped.length} (edited — use --force)`
+                    : '') +
+                '. dxkit has been uninstalled.');
+            // Optional, skippable feedback — a prefilled GitHub issue the user opens
+            // themselves (no telemetry, no auto-submit).
+            if (!values['no-feedback']) {
+                const { buildIssueUrl, readDxkitVersion } = await Promise.resolve().then(() => __importStar(require('./issue-cli')));
+                const url = buildIssueUrl({
+                    type: 'uninstall',
+                    about: '',
+                    dxkitVersion: readDxkitVersion(),
+                    nodeVersion: process.version,
+                    platform: process.platform,
+                    arch: process.arch,
+                });
+                logger.info('');
+                logger.info('Mind sharing why? It genuinely helps. Open a prefilled issue (nothing is sent automatically):');
+                logger.dim(`  ${url}`);
+                logger.dim('  (skip with --no-feedback)');
+            }
+            process.exit(0);
+            break;
+        }
+        case 'floor': {
+            const subCommand = positionals[1];
+            if (subCommand !== 'check') {
+                logger.fail(`Unknown floor subcommand: ${subCommand ?? '(missing)'}. ` +
+                    `Available: vyuh-dxkit floor check [path] [--surface pre-push|ci] [--base <ref>] ` +
+                    `[--correctness | --no-correctness] [--json]`);
+                process.exit(1);
+            }
+            const targetPath = resolveRepoPath(positionals[2]);
+            const surfaceRaw = values.surface ?? 'pre-push';
+            if (surfaceRaw !== 'pre-push' && surfaceRaw !== 'ci') {
+                logger.fail(`Unknown --surface value: ${surfaceRaw}. Expected one of: pre-push, ci.`);
+                process.exit(1);
+            }
+            // --correctness / --no-correctness → the explicit enable/disable override.
+            const flag = values.correctness ? true : values['no-correctness'] ? false : undefined;
+            const { runFloorForSurface } = await Promise.resolve().then(() => __importStar(require('./analyzers/correctness/surface-run')));
+            const outcome = runFloorForSurface({
+                surface: surfaceRaw,
+                cwd: targetPath,
+                base: values.base,
+                flag,
+            });
+            if (values.json) {
+                await emitJson({
+                    surface: outcome.surface,
+                    enabled: outcome.enabled,
+                    ran: outcome.ran,
+                    blocks: outcome.blocks,
+                    reason: outcome.reason,
+                    checks: outcome.result?.checks ?? [],
+                });
+            }
+            else {
+                if (outcome.blocks) {
+                    logger.fail(outcome.summary);
+                    for (const c of outcome.result?.checks.filter((c) => c.status === 'fail') ?? []) {
+                        if (c.output)
+                            process.stdout.write(`\n[${c.pack} ${c.label}]\n${c.output}\n`);
+                    }
+                }
+                else {
+                    logger.success(outcome.summary);
+                }
+            }
+            process.exit(outcome.blocks ? 1 : 0);
+            break;
+        }
         case 'setup-branch-protection': {
             const { runSetupBranchProtection } = await Promise.resolve().then(() => __importStar(require('./setup-branch-protection')));
             const requireReviewsRaw = values['require-reviews'];
@@ -2000,8 +2122,26 @@ async function run(argv) {
                 await runLoopDoctor(cwd, { json: !!values.json });
                 break;
             }
+            if (sub === 'snapshot') {
+                // Capture the correctness-floor entry snapshot — the already-broken set
+                // on the current (pristine) tree — so later Stops block only on
+                // NET-NEW failures. Run at loop activation, before the agent changes
+                // anything, or the recorded set won't be genuinely pre-existing.
+                const { captureFloorSnapshot } = await Promise.resolve().then(() => __importStar(require('./loop/floor-gate')));
+                const { describeCorrectnessFloor } = await Promise.resolve().then(() => __importStar(require('./analyzers/correctness/run')));
+                const result = captureFloorSnapshot(cwd);
+                if (result === null) {
+                    logger.info('No active language pack provides a correctness floor — nothing to snapshot.');
+                    break;
+                }
+                const failing = result.checks.filter((c) => c.status === 'fail').length;
+                logger.success(`Captured correctness-floor entry snapshot (${result.checks.length} check(s), ` +
+                    `${failing} already failing). ${describeCorrectnessFloor(result)}`);
+                break;
+            }
             logger.fail(`Unknown loop subcommand: ${sub ?? '(missing)'}. ` +
-                `Available: vyuh-dxkit loop ledger [show | summarize | clear], vyuh-dxkit loop doctor`);
+                `Available: vyuh-dxkit loop ledger [show | summarize | clear], ` +
+                `vyuh-dxkit loop doctor, vyuh-dxkit loop snapshot`);
             process.exit(1);
             break;
         }