@vyuhlabs/dxkit 2.21.2 → 2.23.0

package/CHANGELOG.md

@@ -7,6 +7,100 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.23.0] - 2026-07-04
+
+### Added — the correctness floor (a loop-safety liveness gate)
+
+The guardrail proves "no net-new findings" (secrets, CVEs, SAST, coverage). It
+does not prove the code still **compiles and its affected tests still pass** — so
+an autonomous agent loop can satisfy the finding gate while shipping code that
+does not build, and even a broken test that lifts coverage gets rewarded. The
+correctness floor closes that gap: a liveness check that asks "does this still
+build, and do the tests it affects still pass?" before an agent may declare
+"done". A failing floor is a pass/fail signal, not a fingerprinted, grandfathered
+finding (there is no "grandfather a syntax error"), so it sits outside the
+baseline and allowlist.
+
+- **Pack-declared, runner-executed** (CLAUDE.md Rule 15). Each language pack
+  declares two pure command builders — `syntaxCheck` (the cheap "does it
+  compile/parse" check) and `affectedTests` (run the tests the change reaches).
+  One runner owns the load-bearing policy in a single place: fail-CLOSED on a
+  real failure (a non-zero exit blocks), fail-OPEN on infrastructure (a missing
+  toolchain or a timeout is a skip, never a block — a slow or un-installed
+  toolchain is not broken code; CI is the backstop). A pack never shells out
+  itself.
+- **All 8 packs, verified against real toolchains**, at the affected granularity
+  each ecosystem natively supports:
+
+  | Pack | Compile | Affected-test granularity |
+  | --- | --- | --- |
+  | TypeScript / JavaScript | `tsc --noEmit` (or the project's typecheck script) | per-file (`vitest related` / `jest --findRelatedTests`) |
+  | Python | `py_compile` | per changed test file (pytest) |
+  | Go | `go build ./...` | changed package(s) |
+  | Rust | `cargo check` | changed crate(s) (`-p`) |
+  | C# / .NET | `dotnet build` | changed test project (`dotnet test <proj>`) |
+  | Java | Maven `test-compile` / Gradle `testClasses` | changed build module (Maven `-pl -am`, Gradle `:mod:test`) |
+  | Kotlin | Maven `test-compile` / Gradle `testClasses` | changed build module |
+  | Ruby | `ruby -c` per changed file | changed spec/test file (RSpec / minitest) |
+
+  A change whose dependents live in another package/module/crate is caught at
+  full/CI scope, not the fast affected surface. The two JVM packs share one
+  `jvm-build.ts` provider (Rule 2).
+- **Three surfaces, one adaptive resolver.** The loop Stop-gate runs the floor
+  by default (an agent must not stop on broken code), scoped to what the loop
+  introduced via a testmon-style entry snapshot, so a pre-existing failure never
+  blocks. The pre-push and CI surfaces are adaptive: when the repo already runs
+  its tests in its own CI, the floor defaults to opt-in there; when no test-CI is
+  detected it runs by default; when a CI exists but its test step is opaque it
+  fails toward on. Precedence: an explicit flag, then a `DXKIT_FLOOR_<SURFACE>`
+  env, then `.dxkit/policy.json` `correctness.surfaces.<surface>`, then the
+  adaptive default.
+- **`vyuh-dxkit floor check [--surface pre-push|ci] [--base <ref>]
+  [--correctness | --no-correctness]`** — the entry point the pre-push hook and
+  CI workflow call. It is baseline-independent, so a brand-new repo with no
+  baseline still gets push-time liveness. The installed pre-push hook runs it
+  before the baseline check; the CI guardrail workflow runs it (full scope) after
+  the finding gate.
+
+### Changed
+
+- `LanguageSupport.correctness` is now a required field: the capability shipped
+  optional and tightened once all eight packs declared it, so a new pack that
+  omits it fails to compile (not just at test time). The `new-lang` scaffold
+  wires a dormant provider so a fresh pack still compiles, with TODOs for the
+  real commands.
+
+## [2.22.0] - 2026-07-02
+
+### Added — the flow feature becomes agent-operable (setup, diagnose, publish, repair)
+
+The UI→API integration gate now has the surfaces an agent (or a person) needs to
+configure, diagnose, and repair it — folded into the commands you already run so
+the CLI stays small.
+
+- **Setup folds into `init`.** There is no standalone `flow init`. When `init`
+  detects a UI→API surface (client calls and/or server routes) it offers the
+  integration gate and asks for the posture — `warn` (default), `block`, or
+  `off` — with a one-line description of each; a repo with no such surface stays
+  silent. `--flow` forces it on with `warn`; `--no-flow` skips it. The dominant
+  base-URL helper to strip and any multiple backend services are surfaced as
+  confirm prompts.
+- **`.dxkit/workspace.json`** — a new top-level participants primitive naming the
+  repos/services of a multi-repo system (path, optional git ref, base URLs).
+- **Diagnose folds into `doctor`.** There is no standalone `flow doctor`. When the
+  repo has a UI→API surface, `doctor` reports a flow-contract diagnosis — the
+  unresolved client calls (each with a reason and a suggested next step), the
+  served routes nobody consumes, and how the served side is resolved — and
+  `doctor --json` carries the whole `flow` object for an agent to read.
+- **`flow publish`** — the multi-repo handshake. Reads `workspace.json` and unions
+  every participant's served routes into this repo's `served.json`, so a consumer
+  repo gates its calls against a provider it does not co-locate. Participants are
+  gathered from a local path, optionally pinned at a git ref; fail-open per
+  participant. A content-hash on the snapshot lets a consumer detect drift.
+- **`dxkit-flow` skill** — the operator surface: setup, diagnose, fix (repair a
+  net-new broken integration a guardrail flagged — never suppress it), and the
+  cross-repo handshake. Thin orchestration over the CLI; `--flow` installs it.
+
 ## [2.21.2] - 2026-07-02
 
 ### Fixed — the flow gate now runs in committed-baseline modes too

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

@@ -0,0 +1,79 @@
+/**
+ * The correctness-floor runner — executes each active pack's syntax + affected-
+ * test commands and folds them into one pass/fail signal.
+ *
+ * Policy, in one place so every surface behaves the same:
+ *   - fail-CLOSED on a real failure — a non-zero exit from a check that ran is a
+ *     genuine syntax error / failing test, and it BLOCKS.
+ *   - fail-OPEN on infrastructure — a missing binary (the toolchain isn't
+ *     installed here) skips the check rather than failing it. A hook must not
+ *     block a developer who simply hasn't installed a linter locally; CI, where
+ *     the toolchain is present, is the backstop.
+ *
+ * Commands come from `LanguageSupport.correctness` via the registry helper
+ * (Rule 6); this module never hardcodes a per-language command. Command
+ * execution is injected so tests exercise the policy without a real toolchain.
+ */
+import type { LanguageId, LanguageSupport } from '../../languages/types';
+import type { CorrectnessCommand, CorrectnessScope } from '../../languages/capabilities/correctness';
+export type CorrectnessStatus = 'pass' | 'fail' | 'skipped-unavailable' | 'skipped-timeout' | 'skipped-none';
+export interface CorrectnessCheckResult {
+    readonly pack: LanguageId;
+    readonly label: string;
+    readonly bin: string;
+    readonly status: CorrectnessStatus;
+    /** Captured output tail — present only on `fail`, for the block message. */
+    readonly output?: string;
+}
+export interface CorrectnessFloorResult {
+    /** True when at least one check actually executed (not all skipped). */
+    readonly ran: boolean;
+    readonly checks: readonly CorrectnessCheckResult[];
+    /** True when any check that ran failed — the floor blocks. */
+    readonly blocks: boolean;
+}
+/** Outcome of running one command:
+ *  - `available:false` → the binary isn't on PATH (fail-open skip);
+ *  - `timedOut:true`   → the command exceeded its wall-clock budget. A SLOW
+ *    suite is not a BROKEN suite, so this is fail-OPEN (skipped), never a block
+ *    — the fast surface stays fast and CI (unbounded) is the backstop;
+ *  - otherwise `code` is the exit status and `output` its tail. */
+export interface CommandOutcome {
+    readonly available: boolean;
+    readonly timedOut?: boolean;
+    readonly code: number;
+    readonly output: string;
+}
+export type CommandExec = (cmd: CorrectnessCommand, cwd: string) => CommandOutcome;
+/**
+ * Build a command exec bounded by an optional per-command wall-clock timeout.
+ * On timeout the child is killed and the outcome is `timedOut` (fail-open),
+ * distinct from a non-zero exit (a real failure, fail-closed). `timeoutMs`
+ * undefined/0 → no timeout (CI, where the full suite is expected to run).
+ */
+export declare function makeCommandExec(timeoutMs?: number): CommandExec;
+/** Default exec: resolve on PATH, run unbounded, capture combined output tail. */
+export declare const defaultCommandExec: CommandExec;
+export interface CorrectnessFloorOptions {
+    readonly cwd: string;
+    readonly changedFiles: readonly string[];
+    readonly scope: CorrectnessScope;
+    /** Active language packs (from `activeLanguagesFromStack` / `-Flags`). */
+    readonly packs: readonly LanguageSupport[];
+    /** Per-command wall-clock budget (ms). A command that exceeds it is a
+     *  fail-OPEN skip, never a block — the fast surface stays fast, CI is the
+     *  backstop. Undefined → no timeout. Ignored when `exec` is injected. */
+    readonly timeoutMs?: number;
+    /** Injected for tests; defaults to real PATH resolution + execFileSync. */
+    readonly exec?: CommandExec;
+}
+/**
+ * Run the correctness floor across the active packs. Never throws — an exec
+ * error surfaces as a `fail` check (fail-closed), a missing binary as
+ * `skipped-unavailable` (fail-open). `blocks` is true iff a check that ran
+ * failed.
+ */
+export declare function runCorrectnessFloor(opts: CorrectnessFloorOptions): CorrectnessFloorResult;
+/** One-line human summary of a floor result (for the Stop-gate / hook block). */
+export declare function describeCorrectnessFloor(result: CorrectnessFloorResult): string;
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/analyzers/correctness/run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAqBlD,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,MAAM,GACN,qBAAqB,GACrB,iBAAiB,GACjB,cAAc,CAAC;AAEnB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACnD,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;mEAKmE;AACnE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,KAAK,cAAc,CAAC;AAInF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,CAoC/D;AAED,kFAAkF;AAClF,eAAO,MAAM,kBAAkB,EAAE,WAA+B,CAAC;AAOjE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;IAC3C;;6EAEyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,sBAAsB,CAiCzF;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAK/E"}

package/dist/analyzers/correctness/run.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * The correctness-floor runner — executes each active pack's syntax + affected-
+ * test commands and folds them into one pass/fail signal.
+ *
+ * Policy, in one place so every surface behaves the same:
+ *   - fail-CLOSED on a real failure — a non-zero exit from a check that ran is a
+ *     genuine syntax error / failing test, and it BLOCKS.
+ *   - fail-OPEN on infrastructure — a missing binary (the toolchain isn't
+ *     installed here) skips the check rather than failing it. A hook must not
+ *     block a developer who simply hasn't installed a linter locally; CI, where
+ *     the toolchain is present, is the backstop.
+ *
+ * Commands come from `LanguageSupport.correctness` via the registry helper
+ * (Rule 6); this module never hardcodes a per-language command. Command
+ * execution is injected so tests exercise the policy without a real toolchain.
+ */
+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.defaultCommandExec = void 0;
+exports.makeCommandExec = makeCommandExec;
+exports.runCorrectnessFloor = runCorrectnessFloor;
+exports.describeCorrectnessFloor = describeCorrectnessFloor;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runner_1 = require("../tools/runner");
+const languages_1 = require("../../languages");
+/**
+ * Is a command's `bin` runnable? A bare name is resolved on PATH (`tsc`,
+ * `cargo`, `npx`); a path-like `bin` (a pack that resolved an absolute
+ * interpreter — a project venv's `python`, a `findTool` path) is accepted when
+ * the file exists. Without the latter, a resolved-path bin would be wrongly
+ * treated as missing and the check skipped (fail-open on a tool that IS
+ * present) — so this keeps the fail-open gate honest for every pack.
+ */
+function binaryAvailable(bin) {
+    if (bin.includes('/') || bin.includes(path.sep)) {
+        try {
+            return fs.statSync(bin).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    return (0, runner_1.commandExists)(bin);
+}
+const OUTPUT_TAIL = 4000; // cap captured output so a block message stays readable
+/**
+ * Build a command exec bounded by an optional per-command wall-clock timeout.
+ * On timeout the child is killed and the outcome is `timedOut` (fail-open),
+ * distinct from a non-zero exit (a real failure, fail-closed). `timeoutMs`
+ * undefined/0 → no timeout (CI, where the full suite is expected to run).
+ */
+function makeCommandExec(timeoutMs) {
+    return (cmd, cwd) => {
+        if (!binaryAvailable(cmd.bin))
+            return { available: false, code: -1, output: '' };
+        try {
+            const out = (0, child_process_1.execFileSync)(cmd.bin, [...cmd.args], {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+                ...(timeoutMs && timeoutMs > 0 ? { timeout: timeoutMs, killSignal: 'SIGTERM' } : {}),
+            });
+            return { available: true, code: 0, output: tail(out) };
+        }
+        catch (e) {
+            const err = e;
+            const combined = `${err.stdout ?? ''}${err.stderr ?? ''}`;
+            // execFileSync sets `code: 'ETIMEDOUT'` (and signal = killSignal) when it
+            // fired the timeout kill. Treat that as a fail-OPEN skip, not a failure —
+            // the run didn't finish, so it says nothing about correctness.
+            if (err.code === 'ETIMEDOUT') {
+                return { available: true, timedOut: true, code: -1, output: tail(combined) };
+            }
+            // A non-numeric status (spawn error, non-timeout signal) is treated as a
+            // failure with code 1 — the binary existed (commandExists passed) but the
+            // run broke.
+            return {
+                available: true,
+                code: typeof err.status === 'number' ? err.status : 1,
+                output: tail(combined),
+            };
+        }
+    };
+}
+/** Default exec: resolve on PATH, run unbounded, capture combined output tail. */
+exports.defaultCommandExec = makeCommandExec();
+function tail(s) {
+    const t = s.trim();
+    return t.length > OUTPUT_TAIL ? `…${t.slice(-OUTPUT_TAIL)}` : t;
+}
+/**
+ * Run the correctness floor across the active packs. Never throws — an exec
+ * error surfaces as a `fail` check (fail-closed), a missing binary as
+ * `skipped-unavailable` (fail-open). `blocks` is true iff a check that ran
+ * failed.
+ */
+function runCorrectnessFloor(opts) {
+    const exec = opts.exec ?? makeCommandExec(opts.timeoutMs);
+    const ctx = { cwd: opts.cwd, changedFiles: opts.changedFiles, scope: opts.scope };
+    const checks = [];
+    for (const { id, provider } of (0, languages_1.activeCorrectnessProviders)(opts.packs)) {
+        const commands = [provider.syntaxCheck(ctx), provider.affectedTests(ctx)];
+        for (const cmd of commands) {
+            if (cmd === null)
+                continue; // pack declined this check for this change
+            const outcome = exec(cmd, opts.cwd);
+            if (!outcome.available) {
+                checks.push({ pack: id, label: cmd.label, bin: cmd.bin, status: 'skipped-unavailable' });
+                continue;
+            }
+            if (outcome.timedOut) {
+                // Exceeded the budget — fail-OPEN. The run didn't finish, so it says
+                // nothing about correctness; CI (unbounded) is the backstop.
+                checks.push({ pack: id, label: cmd.label, bin: cmd.bin, status: 'skipped-timeout' });
+                continue;
+            }
+            checks.push({
+                pack: id,
+                label: cmd.label,
+                bin: cmd.bin,
+                status: outcome.code === 0 ? 'pass' : 'fail',
+                ...(outcome.code === 0 ? {} : { output: outcome.output }),
+            });
+        }
+    }
+    const ran = checks.some((c) => c.status === 'pass' || c.status === 'fail');
+    const blocks = checks.some((c) => c.status === 'fail');
+    return { ran, checks, blocks };
+}
+/** One-line human summary of a floor result (for the Stop-gate / hook block). */
+function describeCorrectnessFloor(result) {
+    const failed = result.checks.filter((c) => c.status === 'fail');
+    if (failed.length === 0)
+        return 'correctness floor: all checks passed';
+    const which = failed.map((c) => `${c.pack} ${c.label}`).join(', ');
+    return `correctness floor: ${failed.length} check(s) failed — ${which}`;
+}
+//# sourceMappingURL=run.js.map

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

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

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

@@ -0,0 +1,73 @@
+/**
+ * Run the correctness floor for a NON-loop surface (`pre-push` / `ci`).
+ *
+ * The loop Stop-gate has its own runner (`src/loop/stop-gate.ts`) because it
+ * diffs against a cheap entry snapshot to block only on NET-NEW failures. The
+ * pre-push and CI surfaces are point-in-time LIVENESS gates instead: they run
+ * the floor at the current tree and are fail-CLOSED on the surface's scope.
+ * There is no net-new diffing here (that would cost a base-ref worktree run on
+ * every push / PR); the entry-snapshot trick is the loop's alone.
+ *
+ *   - `pre-push` — AFFECTED scope, changed files computed vs the merge-base with
+ *     the integration branch. Runs on the developer's machine where the
+ *     toolchain is present, so the floor is meaningful; a per-command timeout
+ *     keeps `git push` fast. Blocks the push when the affected tests don't pass.
+ *     (It does not distinguish a pre-existing red test in a touched module from
+ *     a newly-broken one — that distinction is the loop Stop-gate's job. Bypass
+ *     with `--no-verify`.)
+ *   - `ci` — FULL scope, no timeout (the full suite is expected to run). The
+ *     backstop.
+ *
+ * Both surfaces are ADAPTIVE (`resolveCorrectnessSurface`): when the repo
+ * already runs its tests in its own CI, the floor defaults to opt-in here, so
+ * this runner returns a disabled no-op unless explicitly enabled.
+ */
+import type { LanguageSupport } from '../../languages/types';
+import { type CommandExec, type CorrectnessFloorResult } from './run';
+/** The surfaces this runner serves (the loop-stop surface has its own runner). */
+export type RunnableSurface = 'pre-push' | 'ci';
+export interface SurfaceFloorOutcome {
+    readonly surface: RunnableSurface;
+    /** Was the floor enabled on this surface (via the resolver)? */
+    readonly enabled: boolean;
+    /** Why it resolved the way it did (or why it was skipped). */
+    readonly reason: string;
+    /** Did any check actually execute (false when disabled / no pack / all skipped)? */
+    readonly ran: boolean;
+    /** Does the floor block this surface (a real failure)? Always false when not `ran`. */
+    readonly blocks: boolean;
+    /** One-line human summary for CLI / hook output. */
+    readonly summary: string;
+    readonly result?: CorrectnessFloorResult;
+}
+/**
+ * The merge-base of HEAD against the most likely integration branch, so the
+ * pre-push floor scopes to what this branch actually introduces. Tries, in
+ * order: an explicit ref, the tracking upstream, then the common remote/local
+ * default-branch names. Returns '' when none resolve (caller then runs full).
+ */
+export declare function resolvePrePushBase(cwd: string, explicit?: string): string;
+export interface RunFloorForSurfaceOptions {
+    readonly surface: RunnableSurface;
+    readonly cwd: string;
+    /** Explicit base ref for pre-push affected scoping (else auto-resolved). */
+    readonly base?: string;
+    /** Explicit `--correctness` / `--no-correctness` override (highest precedence). */
+    readonly flag?: boolean;
+    /** Injected for tests; defaults to the real PATH-resolving exec. */
+    readonly exec?: CommandExec;
+    /** Injected for tests; defaults to the active packs detected at `cwd`. */
+    readonly packs?: readonly LanguageSupport[];
+    /** Injected for tests; defaults to the real adaptive resolver. */
+    readonly resolveEnabled?: (surface: RunnableSurface, cwd: string) => {
+        enabled: boolean;
+        reason: string;
+    };
+}
+/**
+ * Resolve enablement + scope for a surface and run the floor. Never throws — a
+ * disabled surface, an absent pack, or an all-skipped run all return
+ * `blocks: false` (the caller exits 0); only a real check failure blocks.
+ */
+export declare function runFloorForSurface(opts: RunFloorForSurfaceOptions): SurfaceFloorOutcome;
+//# sourceMappingURL=surface-run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surface-run.d.ts","sourceRoot":"","sources":["../../../src/analyzers/correctness/surface-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC5B,MAAM,OAAO,CAAC;AAGf,kFAAkF;AAClF,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,IAAI,CAAC;AAEhD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,uFAAuF;IACvF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CAC1C;AAeD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CASzE;AAUD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IAC5C,kEAAkE;IAClE,QAAQ,CAAC,cAAc,CAAC,EAAE,CACxB,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,KACR;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,mBAAmB,CAoEvF"}

package/dist/analyzers/correctness/surface-run.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Run the correctness floor for a NON-loop surface (`pre-push` / `ci`).
+ *
+ * The loop Stop-gate has its own runner (`src/loop/stop-gate.ts`) because it
+ * diffs against a cheap entry snapshot to block only on NET-NEW failures. The
+ * pre-push and CI surfaces are point-in-time LIVENESS gates instead: they run
+ * the floor at the current tree and are fail-CLOSED on the surface's scope.
+ * There is no net-new diffing here (that would cost a base-ref worktree run on
+ * every push / PR); the entry-snapshot trick is the loop's alone.
+ *
+ *   - `pre-push` — AFFECTED scope, changed files computed vs the merge-base with
+ *     the integration branch. Runs on the developer's machine where the
+ *     toolchain is present, so the floor is meaningful; a per-command timeout
+ *     keeps `git push` fast. Blocks the push when the affected tests don't pass.
+ *     (It does not distinguish a pre-existing red test in a touched module from
+ *     a newly-broken one — that distinction is the loop Stop-gate's job. Bypass
+ *     with `--no-verify`.)
+ *   - `ci` — FULL scope, no timeout (the full suite is expected to run). The
+ *     backstop.
+ *
+ * Both surfaces are ADAPTIVE (`resolveCorrectnessSurface`): when the repo
+ * already runs its tests in its own CI, the floor defaults to opt-in here, so
+ * this runner returns a disabled no-op unless explicitly enabled.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePrePushBase = resolvePrePushBase;
+exports.runFloorForSurface = runFloorForSurface;
+const child_process_1 = require("child_process");
+const languages_1 = require("../../languages");
+const changed_files_1 = require("../../baseline/changed-files");
+const run_1 = require("./run");
+const surface_1 = require("./surface");
+/** Best-effort git stdout for a fixed arg vector; '' on any failure. */
+function gitOut(cwd, args) {
+    try {
+        return (0, child_process_1.execFileSync)('git', [...args], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * The merge-base of HEAD against the most likely integration branch, so the
+ * pre-push floor scopes to what this branch actually introduces. Tries, in
+ * order: an explicit ref, the tracking upstream, then the common remote/local
+ * default-branch names. Returns '' when none resolve (caller then runs full).
+ */
+function resolvePrePushBase(cwd, explicit) {
+    const candidates = explicit
+        ? [explicit]
+        : ['@{upstream}', 'origin/HEAD', 'origin/main', 'origin/master', 'main', 'master'];
+    for (const ref of candidates) {
+        const mb = gitOut(cwd, ['merge-base', 'HEAD', ref]);
+        if (mb)
+            return mb;
+    }
+    return '';
+}
+/** Per-command wall-clock budget for the fast (pre-push) surface. Env-tunable;
+ *  CI runs unbounded (the full suite is expected to run to completion). */
+function prePushTimeoutMs() {
+    const raw = process.env.DXKIT_FLOOR_TIMEOUT_MS;
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : 120_000;
+}
+/**
+ * Resolve enablement + scope for a surface and run the floor. Never throws — a
+ * disabled surface, an absent pack, or an all-skipped run all return
+ * `blocks: false` (the caller exits 0); only a real check failure blocks.
+ */
+function runFloorForSurface(opts) {
+    const { surface, cwd } = opts;
+    const res = opts.resolveEnabled
+        ? opts.resolveEnabled(surface, cwd)
+        : (0, surface_1.resolveCorrectnessSurface)({ surface, cwd, flag: opts.flag });
+    if (!res.enabled) {
+        return {
+            surface,
+            enabled: false,
+            reason: res.reason,
+            ran: false,
+            blocks: false,
+            summary: `correctness floor (${surface}): disabled — ${res.reason}`,
+        };
+    }
+    const packs = (opts.packs ?? (0, languages_1.detectActiveLanguages)(cwd)).filter((p) => p.correctness);
+    if (packs.length === 0) {
+        return {
+            surface,
+            enabled: true,
+            reason: res.reason,
+            ran: false,
+            blocks: false,
+            summary: `correctness floor (${surface}): no active language pack provides a floor`,
+        };
+    }
+    let scope = 'full';
+    let changedFiles = [];
+    let timeoutMs;
+    if (surface === 'pre-push') {
+        scope = 'affected';
+        const base = resolvePrePushBase(cwd, opts.base);
+        // Empty changedFiles (base unresolved / diff undeterminable) → the packs
+        // treat the scope as full, per the CorrectnessContext contract.
+        changedFiles = base ? ((0, changed_files_1.computeChangedFiles)(cwd, base) ?? []) : [];
+        timeoutMs = prePushTimeoutMs();
+    }
+    // ci: full scope, no timeout — the full suite runs to completion.
+    const result = (0, run_1.runCorrectnessFloor)({
+        cwd,
+        changedFiles,
+        scope,
+        packs,
+        timeoutMs,
+        exec: opts.exec,
+    });
+    if (!result.ran) {
+        return {
+            surface,
+            enabled: true,
+            reason: res.reason,
+            ran: false,
+            blocks: false,
+            summary: `correctness floor (${surface}): all checks skipped (toolchain not present) — CI is the backstop`,
+        };
+    }
+    return {
+        surface,
+        enabled: true,
+        reason: res.reason,
+        ran: true,
+        blocks: result.blocks,
+        summary: (0, run_1.describeCorrectnessFloor)(result),
+        result,
+    };
+}
+//# sourceMappingURL=surface-run.js.map

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

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