no-mistakes 0.84.2 → 0.86.0

package/analyze-project-types.d.ts

@@ -1,9 +1,6 @@
-import type {
-  CiEnvOptions,
-  CiImpactOptions,
-  CiTopologyOptions,
-  ImpactedChecksOptions,
-} from "./ci-types";
+import type { TestsAuditOptions } from "./test-audit-types";
+import type { CiTopologyOptions } from "./workflow-topology-types";
+import type { CiEnvOptions, CiImpactOptions, ImpactedChecksOptions } from "./ci-types";
 import type { FetchesOptions, FlowOptions } from "./flow-types";
 import type { ImportUsagesOptions } from "./import-usage-types";
 import type { MermaidValidationOptions } from "./mermaid-types";
@@ -60,7 +57,10 @@ type BatchedReactUsagesOptions = Pick<
   "root" | "tsconfig" | "config" | "targets" | "include"
 > &
   Required<Pick<ProjectOptions, "target">>;
-type BatchedCheckOptions = Pick<CheckOptions, "root" | "tsconfig" | "config" | "includeSuppressed">;
+type BatchedCheckOptions = Pick<
+  CheckOptions,
+  "root" | "tsconfig" | "config" | "includeSuppressed" | "includeRunnerConfigDeadlines"
+>;
 type BatchedQueryFileOptions<T> = Omit<T, "root" | "tsconfig">;
 type BatchedRootConfigOptions<T> = Omit<T, "root" | "config">;
 type BatchedRootTsConfigOptions<T> = Omit<T, "root" | "tsconfig" | "config">;
@@ -115,6 +115,7 @@ export type AnalyzeProjectReportRequest =
   | ({ type: "fetches"; id?: string } & BatchedRootConfigOptions<FetchesOptions>)
   | ({ type: "dataPw"; id?: string } & BatchedRootConfigOptions<DataPwOptions>)
   | ({ type: "registryExtension"; id?: string } & Omit<RegistryExtensionOptions, "root">)
+  | ({ type: "testsAudit"; id?: string } & TestsAuditOptions)
   | ({ type: "testsPlan"; id?: string } & BatchedRootTsConfigOptions<TestsPlanOptions>)
   | ({ type: "testsImpact"; id?: string } & BatchedRootTsConfigOptions<TestsImpactOptions>)
   | ({ type: "testsTargets"; id?: string } & Omit<TestsTargetsOptions, "root" | "config">)

package/check-report-types.d.ts

@@ -6,6 +6,8 @@ export interface CheckReport {
   queues: QueueCheckFinding[];
   rules: RuleFinding[];
   integration: IntegrationFinding[];
+  /** Present only when requested; declaration evidence, not runtime closure. */
+  runnerConfigDeadlines?: RunnerConfigDeadlineEvidence[];
   codebase: UniqueExportFinding[];
   warnings: string[];
   advisories: RuleFinding[];
@@ -55,3 +57,50 @@ export interface UniqueExportFinding {
   exportKind: string;
   message: string;
 }
+
+export type RunnerDeadlineStatus = "notRequested" | "prepared" | "failed";
+export interface RunnerConfigDeadlineEvidence {
+  framework: "playwright" | "vitest";
+  status: RunnerDeadlineStatus;
+  configs: ConfigDeadlineEvidence[];
+}
+export type ConfigDeadlineEvidence =
+  | { status: "prepared"; config: string; projects: ProjectDeadlineEvidence[] }
+  | { status: "failed"; config: string; error: string };
+export interface ProjectDeadlineEvidence {
+  config: string | null;
+  workspace: boolean;
+  policyName: string | null;
+  runnerProjectArg: string | null;
+  scope: string | null;
+  case: DeclaredDeadlineSlot;
+  hook: DeclaredDeadlineSlot;
+  fixture: DeclaredDeadlineSlot;
+}
+export type DeclaredDeadlineSlot =
+  | { status: "absent" }
+  | { status: "known"; milliseconds: number; provenance: DeadlineProvenance }
+  | { status: "unknown"; reason: DeclaredDeadlineUnknownReason; provenance: DeadlineProvenance };
+export type DeclaredDeadlineUnknownReason =
+  | "expression"
+  | "nonFinite"
+  | "opaqueSpread"
+  | "opaqueTestObject"
+  | "computedProperty"
+  | "unresolvedExtends"
+  | "unresolvedInheritance"
+  | "unprovedConfigRoot"
+  | "accessor"
+  | "unsupportedConfigCall"
+  | "unprovedBinding";
+export interface DeadlineProvenance {
+  /** Request-root-relative slash path; outside-root sources retain their path. */
+  path: string;
+  /** Half-open source byte offsets, never line numbers; null when unavailable. */
+  span: [number, number] | null;
+  inheritedThrough: DeadlineInheritanceEvidence[];
+}
+export interface DeadlineInheritanceEvidence {
+  path: string;
+  project: string | null;
+}

package/declared-payload-types.d.ts

@@ -0,0 +1,19 @@
+/** Options for the configured `declared-payload-compatibility` check rule. */
+export interface DeclaredPayloadCompatibilityOptions {
+  contracts?: DeclaredPayloadContract[];
+}
+
+/** Producer declarations must accept only values accepted by the consumer. */
+export interface DeclaredPayloadContract {
+  name: string;
+  producer: DeclaredPayloadSchema;
+  consumer: DeclaredPayloadSchema;
+}
+
+/** A visible JSON document selected explicitly; no runtime adoption is inferred. */
+export interface DeclaredPayloadSchema {
+  /** Root-relative path within this rule application's visible file scope. */
+  file: string;
+  /** RFC 6901 JSON pointer; omitted or empty selects the whole document. */
+  pointer?: string;
+}

package/index-ci-infra.d.ts

@@ -28,6 +28,8 @@ import type {
   SwiftOptions,
   SwiftTestTargetRow,
   TestForRow,
+  TestAuditReport,
+  TestsAuditOptions,
   WithInvocationOptions,
   WorkflowTopology,
   WorkflowTopologyIndex,
@@ -73,3 +75,7 @@ export function swiftTestTargets(
   options: WithInvocationOptions<SwiftOptions & { file: string }>,
 ): Promise<SwiftTestTargetRow[]>;
 export function version(): Promise<string>;
+
+export function testsAudit(
+  options: WithInvocationOptions<TestsAuditOptions>,
+): Promise<TestAuditReport>;

package/index.js

@@ -66,7 +66,13 @@ const jsonApis = createJsonApis({
   symbols: "symbolsJson",
 });
 
-const CAMELIZE_REPORTS = new Set(["testsPlan", "testsImpact", "testsTargets", "testsGraph"]);
+const CAMELIZE_REPORTS = new Set([
+  "testsAudit",
+  "testsPlan",
+  "testsImpact",
+  "testsTargets",
+  "testsGraph",
+]);
 const acquirePlanningArtifactLock = createPlanningArtifactLock(native);
 
 async function analyzeProject(options = {}) {
@@ -163,6 +169,7 @@ module.exports.serverRouteEdges = planning.serverRouteEdges;
 module.exports.serverRouteList = planning.serverRouteList;
 module.exports.serverRouteRelated = planning.serverRouteRelated;
 module.exports.serverRoutes = planning.serverRoutes;
+module.exports.testsAudit = planning.testsAudit;
 module.exports.testsGraph = planning.testsGraph;
 module.exports.testsImpact = planning.testsImpact;
 module.exports.testsPlan = planning.testsPlan;

package/index.mjs

@@ -54,6 +54,7 @@ export const {
   swiftImporters,
   swiftTestTargets,
   symbols,
+  testsAudit,
   testsComment,
   testsGraph,
   testsGraphMermaid,

package/invocation-types.d.ts

@@ -2,13 +2,19 @@
 export interface InvocationOptions {
   /** Command execution timeout in whole non-negative seconds. Omit, `0`, or `null` disables it. CLI default remains 30. */
   timeout?: number | null;
-  /** Maximum time to wait for the machine-wide lock, in whole non-negative seconds. Omit, `0`, or `null` waits indefinitely. CLI default remains 30. */
+  /** Maximum time to wait for the current user's invocation lock (shared across project roots), in whole non-negative seconds. Omit, `0`, or `null` waits indefinitely. CLI default remains 30. */
   lockTimeout?: number | null;
   /** Fail immediately instead of waiting when another invocation holds the lock. */
   failOnLock?: boolean;
   /**
-   * Rayon worker count. Omit or `0` uses the CPU count, matching CLI `--jobs 0`.
-   * A positive integer pins the process pool on the first N-API call.
+   * Rayon worker count. A positive integer takes precedence over `RAYON_NUM_THREADS`.
+   * Omit, `0`, or `null` uses `RAYON_NUM_THREADS`, falling back to CPU count when
+   * unset or invalid, matching CLI `--jobs 0`.
+   * The first analysis request with valid UTF-8 JSON and invocation controls that
+   * acquires the invocation lock initializes the process-wide pool before
+   * command-specific options are validated. A later command-validation failure
+   * can therefore still select the pool; JSON/control or lock failures cannot.
+   * Later calls cannot resize an already initialized pool.
    */
   jobs?: number | null;
   /** `ci` sets unbounded command and lock timeouts. CLI `--profile ci` does the same. */

package/named-query-types.d.ts

@@ -37,7 +37,7 @@ export interface EffectsOptions {
   tsconfig?: string;
   /** Path to the no-mistakes config file (e.g. .no-mistakes.yml). Auto-discovered in root if omitted. */
   config?: string;
-  /** Effect kind to resolve (a key under `effects:` in config). */
+  /** Effect family from config; supports spelling lists and binding-aware module/export targets. */
   kind: string;
   /** Entry file whose transitive imports are scanned. */
   entry: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.84.2",
+  "version": "0.86.0",
   "description": "Deterministic impact maps, test plans, Playwright coverage, and repository checks for coding agents",
   "license": "MIT",
   "repository": {
@@ -24,6 +24,7 @@
     "planning-impact-artifacts-privacy.js",
     "planning-impact-cli.js",
     "planning.js",
+    "planning-artifact-inputs.js",
     "workflow-topology-index.js",
     "workflow-topology-index-helpers.js",
     "scripts/native-package.js",
@@ -45,9 +46,9 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "no-mistakes-darwin-arm64": "0.84.2",
-    "no-mistakes-linux-arm64-gnu": "0.84.2",
-    "no-mistakes-linux-x64-gnu": "0.84.2",
-    "no-mistakes-win32-x64-msvc": "0.84.2"
+    "no-mistakes-darwin-arm64": "0.86.0",
+    "no-mistakes-linux-arm64-gnu": "0.86.0",
+    "no-mistakes-linux-x64-gnu": "0.86.0",
+    "no-mistakes-win32-x64-msvc": "0.86.0"
   }
 }

package/planning-artifact-inputs.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const fs = require("node:fs/promises");
+
+function camelizeKey(key) {
+  return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function decamelizeKey(key) {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+function mapKeys(value, mapKey) {
+  if (Array.isArray(value)) return value.map((item) => mapKeys(item, mapKey));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [mapKey(key), mapKeys(nested, mapKey)]),
+    );
+  }
+  return value;
+}
+
+function camelizeValue(value) {
+  return mapKeys(value, camelizeKey);
+}
+
+function decamelizeValue(value) {
+  return mapKeys(value, decamelizeKey);
+}
+
+function loadPlanJson(planJson) {
+  let parsed = planJson;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return planJson;
+    }
+  }
+  if (parsed && typeof parsed === "object") {
+    return decamelizeValue(parsed);
+  }
+  return planJson;
+}
+
+async function readPlanFile(planPath) {
+  try {
+    return JSON.parse(await fs.readFile(planPath, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+async function decamelizePlanOptions(options = {}) {
+  const next = { ...options };
+  if (next.planJson != null) {
+    next.planJson = loadPlanJson(next.planJson);
+  } else if (typeof next.plan === "string") {
+    const document = await readPlanFile(next.plan);
+    if (document !== undefined) {
+      next.planJson = loadPlanJson(document);
+      delete next.plan;
+    }
+  }
+  return next;
+}
+
+module.exports = { camelizeValue, decamelizePlanOptions, loadPlanJson, readPlanFile };

package/planning.js

@@ -7,6 +7,12 @@ const { resolveNativePackage } = require("./scripts/native-package");
 const native = require(
   process.env.NO_MISTAKES_TEST_NAPI_ADDON_PATH || resolveNativePackage().addonPath,
 );
+const {
+  camelizeValue,
+  decamelizePlanOptions,
+  loadPlanJson,
+  readPlanFile,
+} = require("./planning-artifact-inputs");
 const PLAN_INPUT_REPORTS = new Set(["testsComment", "testsGraph", "testsGraphMermaid"]);
 
 async function callJson(fn, options) {
@@ -23,69 +29,6 @@ function createJsonApis(descriptors) {
   );
 }
 
-function camelizeKey(key) {
-  return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-
-function decamelizeKey(key) {
-  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-
-function mapKeys(value, mapKey) {
-  if (Array.isArray(value)) return value.map((item) => mapKeys(item, mapKey));
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [mapKey(key), mapKeys(nested, mapKey)]),
-    );
-  }
-  return value;
-}
-
-function camelizeValue(value) {
-  return mapKeys(value, camelizeKey);
-}
-
-function decamelizeValue(value) {
-  return mapKeys(value, decamelizeKey);
-}
-
-function loadPlanJson(planJson) {
-  let parsed = planJson;
-  if (typeof parsed === "string") {
-    try {
-      parsed = JSON.parse(parsed);
-    } catch {
-      return planJson;
-    }
-  }
-  if (parsed && typeof parsed === "object") {
-    return decamelizeValue(parsed);
-  }
-  return planJson;
-}
-
-async function readPlanFile(planPath) {
-  try {
-    return JSON.parse(await fs.readFile(planPath, "utf8"));
-  } catch {
-    return undefined;
-  }
-}
-
-async function decamelizePlanOptions(options = {}) {
-  const next = { ...options };
-  if (next.planJson != null) {
-    next.planJson = loadPlanJson(next.planJson);
-  } else if (typeof next.plan === "string") {
-    const document = await readPlanFile(next.plan);
-    if (document !== undefined) {
-      next.planJson = loadPlanJson(document);
-      delete next.plan;
-    }
-  }
-  return next;
-}
-
 async function prepareWhyPlan(options = {}) {
   const next = { ...options };
   let document = next.planJson;
@@ -163,6 +106,7 @@ const jsonApis = createJsonApis({
   serverRouteList: "serverRouteListJson",
   serverRouteRelated: "serverRouteRelatedJson",
   serverRoutes: "serverRoutesJson",
+  testsAudit: "testsAuditJson",
   testsGraph: "testsGraphJson",
   testsImpact: "testsImpactJson",
   testsPlan: "testsPlanJson",
@@ -170,6 +114,10 @@ const jsonApis = createJsonApis({
   testsWhy: "testsWhyJson",
 });
 
+async function testsAudit(options) {
+  return camelizeValue(await jsonApis.testsAudit(options));
+}
+
 async function testsPlan(options) {
   return camelizeValue(await jsonApis.testsPlan(options));
 }
@@ -206,6 +154,7 @@ module.exports = {
   testsComment,
   testsGraphMermaid,
   ...jsonApis,
+  testsAudit,
   testsGraph,
   testsImpact,
   testsPlan,

package/postgres-insert-types.d.ts

@@ -6,6 +6,7 @@ import type {
   PostgresSqlSpan,
 } from "./postgres-source-types";
 import type { PostgresSqlQuery } from "./postgres-query-types";
+import type { PostgresSqlReturningItem } from "./postgres-query-statement-types";
 /** Syntactic facts only: complete does not establish replay safety. */
 export interface PostgresSqlInsert {
   table: PostgresSqlName | null;
@@ -15,6 +16,8 @@ export interface PostgresSqlInsert {
   columnSources: PostgresSqlInsertColumnSources;
   source: PostgresSqlInsertSource;
   onConflict: PostgresSqlConflict | null;
+  /** Empty when the statement has no RETURNING clause. */
+  returning: PostgresSqlReturningItem[];
   span: PostgresSqlSpan | null;
   /** Syntax completeness is independent of provenance and does not imply replay safety. */
   complete: boolean;

package/postgres-procedural-types.d.ts

@@ -14,10 +14,35 @@ export interface PostgresSqlProceduralBlock {
   bodyEncoding: PostgresSqlBodyEncoding;
   bodySpan: PostgresSqlSpan;
   statements: PostgresSqlStatement[];
+  /** Classified source occurrences in source order. Visibility is not execution. */
+  occurrences: PostgresSqlProceduralOccurrence[];
   diagnostics: PostgresSqlDiagnostic[];
   complete: boolean;
 }
 
+/** Closed classification for one procedural source occurrence. */
+export type PostgresSqlProceduralOccurrenceKind =
+  | "utility"
+  | "controlFlow"
+  | "dml"
+  | "dynamicExecute"
+  | "unknown";
+
+/** One statically visible occurrence and the occurrences it contains.
+ * `utility` is a non-DML command such as CREATE TYPE.
+ * `controlFlow` is IF, LOOP, RAISE, or another recognized procedural form.
+ * `dml` means INSERT, UPDATE, DELETE, or MERGE text is present; it does not run.
+ * `dynamicExecute` is EXECUTE of a non-literal command, including format and
+ * concatenation that is not wholly literal. `unknown` fails closed.
+ * Nested occurrences stay in source order. Spans use original source coordinates.
+ * Quoted strings and comments are not keywords.
+ */
+export interface PostgresSqlProceduralOccurrence {
+  kind: PostgresSqlProceduralOccurrenceKind;
+  span: PostgresSqlSpan;
+  occurrences: PostgresSqlProceduralOccurrence[];
+}
+
 /** Branch DDL describes source occurrences, never guaranteed execution. */
 export interface PostgresSqlConditionalBranch {
   condition: PostgresSqlExpression | null;

package/postgres-query-statement-types.d.ts

@@ -5,7 +5,7 @@ import type {
   PostgresSqlName,
   PostgresSqlSpan,
 } from "./postgres-source-types";
-import type { PostgresSqlConflict } from "./postgres-insert-types";
+import type { PostgresSqlConflict, PostgresSqlInsertColumnSources } from "./postgres-insert-types";
 import type { PostgresSqlQueryUnsupported } from "./postgres-query-types";
 
 /** Syntactic modifying bodies in source order, not PostgreSQL execution order.
@@ -37,6 +37,8 @@ export interface PostgresSqlCteInsert {
   alias: PostgresSqlIdentifier | null;
   columns: PostgresSqlName[];
   columnsOmitted: boolean;
+  /** Omitted for non-RETURNING CTE inserts. RETURNING keeps direct column lineage. */
+  columnSources?: PostgresSqlInsertColumnSources;
   source: PostgresSqlCteInsertSource;
   onConflict: PostgresSqlConflict | null;
   diagnostics: PostgresSqlDiagnostic[];

package/postgres-query-types.d.ts

@@ -87,6 +87,8 @@ export interface PostgresSqlQueryColumn {
 }
 export interface PostgresSqlPredicateContext {
   mandatory: boolean;
+  /** Required conjunct after wrapping NOT inverts AND/OR; null through opaque wrappers. */
+  effectiveMandatory: boolean | null;
   underOr: boolean;
   underNot: boolean;
   underCase: boolean;
@@ -105,7 +107,21 @@ export interface PostgresSqlQueryEquality {
 export interface PostgresSqlQueryExists {
   scopeId: number;
   subqueryScopeId: number;
+  /** The EXISTS node's own flag. Wrapping `NOT` is not folded into this value. */
   negated: boolean;
+  /**
+   * NOT operators that apply to this EXISTS: each wrapping `NOT` (parentheses
+   * are transparent) plus one when `negated` is true.
+   */
+  notDepth: number;
+  /**
+   * `notDepth % 2 === 1` when this EXISTS is not under a boolean test, CASE,
+   * or other wrapper. `null` when `context.underBooleanTest`,
+   * `context.underCase`, or `context.underOther` is set: those wrappers can
+   * invert or hide polarity, and this field does not guess. Always present.
+   * Distinct from `negated` and from `context.underNot`.
+   */
+  effectiveNegated: boolean | null;
   context: PostgresSqlPredicateContext;
   correlated: boolean;
   correlations: PostgresSqlQueryColumn[];

package/query-types.d.ts

@@ -19,7 +19,27 @@ export interface ImportersTestImpact {
   count: number;
 }
 
-export interface ImportersResult {
+/** A recorded gap in the prepared reverse-query source inventory. */
+export type QueryIncompleteReason =
+  | "operational-error"
+  | "parse-error"
+  | "missing-facts"
+  | "missing-symbols";
+
+export interface QueryIncompleteFile {
+  /** Root-relative candidate path; relevance can be unknown when imports are missing. */
+  file: string;
+  reason: QueryIncompleteReason;
+  message: string;
+}
+
+export interface QueryDiagnostics {
+  /** Recorded collection gaps exist. False does not guarantee exhaustive references. */
+  partial: boolean;
+  incompleteFiles: QueryIncompleteFile[];
+}
+
+export interface ImportersResult extends QueryDiagnostics {
   file: string;
   directImporters: string[];
   dependentsCount: number;
@@ -43,6 +63,10 @@ export interface ExportRowResult {
 export interface ExportsOfResult {
   file: string;
   exports: ExportRowResult[];
+  /** Omitted with noImporters because the reverse scan was not requested. */
+  partial?: boolean;
+  /** Omitted with noImporters. */
+  incompleteFiles?: QueryIncompleteFile[];
 }
 
 export interface DeadExportsOptions extends QueryFileOptions {
@@ -56,14 +80,14 @@ export interface DeadExportResult {
   importerCount: number;
 }
 
-export interface DeadExportsResult {
+export interface DeadExportsResult extends QueryDiagnostics {
   file: string;
   results: DeadExportResult[];
   anyDead: boolean;
 }
 
 export interface CallSitesOptions extends QueryFileOptions {
-  /** The exported function name to find call sites for. */
+  /** Exported callable to resolve through namespaces, static lexical aliases, and barrels. */
   exportName: string;
 }
 
@@ -90,7 +114,7 @@ export interface CallSite {
   args: ArgShape[];
 }
 
-export interface CallSitesResult {
+export interface CallSitesResult extends QueryDiagnostics {
   file: string;
   export: string;
   callSites: CallSite[];

package/test-audit-types.d.ts

@@ -0,0 +1,100 @@
+import type { ImpactReason, TestPlan } from "./test-types";
+
+/** Caller-recorded immutable identities; audit compares but does not verify the digests. */
+export interface TestAuditProvenance {
+  /** Lowercase 40- or 64-digit Git revision. */
+  checkoutRevision: string;
+  /** SHA-256 of the complete source/config snapshot, including dirty changes. */
+  sourceDigest: string;
+  /** SHA-256 of the runner/project/config/instrumentation scope. */
+  scopeDigest: string;
+}
+
+export interface TestAuditSymbol {
+  file: string;
+  /** Exact exported/callable identity agreed upon by the producer and adapter. */
+  symbol: string;
+}
+
+export interface TestAuditPlanArtifact {
+  schemaVersion: 1;
+  provenance: TestAuditProvenance;
+  plan: TestPlan;
+  /** Explicit root-relative scope; must match plan.changedFiles when nonempty. */
+  changedFiles: string[];
+  /** Refines matching for these files to exact symbols rather than any file execution. */
+  changedSymbols: TestAuditSymbol[];
+}
+
+export interface TestAuditObservation {
+  /** Inventory identity; does not alone prove execution. */
+  testFile: string;
+  /** Explicit execution evidence, including the test file itself when its source was evaluated. */
+  executedFiles: string[];
+  executedSymbols: TestAuditSymbol[];
+  /** Complete file AND symbol tracing for the declared scope; false makes negative evidence unknown. */
+  traceComplete: boolean;
+}
+
+export interface TestAuditObservationsArtifact {
+  schemaVersion: 1;
+  provenance: TestAuditProvenance;
+  granularity: "per-test-file";
+  suite: "full";
+  /** Declares the full suite finished; does not assert instrumentation completeness. */
+  complete: true;
+  /** One merged observation per test file; aggregate suite coverage is unsupported. */
+  tests: TestAuditObservation[];
+}
+
+export interface TestsAuditPlanFileInput {
+  plan: string;
+  planJson?: never;
+}
+
+export interface TestsAuditPlanInlineInput {
+  plan?: never;
+  planJson: TestAuditPlanArtifact | string;
+}
+
+export interface TestsAuditObservationsFileInput {
+  observations: string;
+  observationsJson?: never;
+}
+
+export interface TestsAuditObservationsInlineInput {
+  observations?: never;
+  observationsJson: TestAuditObservationsArtifact | string;
+}
+
+export type TestsAuditPlanInput = TestsAuditPlanFileInput | TestsAuditPlanInlineInput;
+export type TestsAuditObservationsInput =
+  | TestsAuditObservationsFileInput
+  | TestsAuditObservationsInlineInput;
+/** Requires exactly one path or inline artifact for each input. */
+export type TestsAuditOptions = TestsAuditPlanInput & TestsAuditObservationsInput;
+
+export interface TestAuditExecutionEvidence {
+  testFile: string;
+  matchedFiles: string[];
+  matchedSymbols: TestAuditSymbol[];
+}
+
+export interface TestAuditSelectionEvidence {
+  testFile: string;
+  /** Original static selection reasons for investigating excess selection. */
+  reasons: ImpactReason[];
+}
+
+export interface TestAuditReport {
+  provenance: TestAuditProvenance;
+  observedTestFiles: number;
+  selectedTestFiles: number;
+  selectedObservedTests: TestAuditExecutionEvidence[];
+  missedObservedTests: TestAuditExecutionEvidence[];
+  selectedWithoutObservedExecution: TestAuditSelectionEvidence[];
+  selectedWithoutObservations: string[];
+  selectedWithIncompleteTraces: string[];
+  /** Always explains the limits of observed execution and caller-recorded provenance. */
+  limitations: string[];
+}

package/test-types.d.ts

@@ -1,5 +1,14 @@
 import type { SymbolEntrypoint } from "./traversal-types";
 
+/** A named project under `.no-mistakes.yml` `tests.vitest.projects`. */
+export interface VitestProjectPolicy {
+  include?: string[];
+  exclude?: string[];
+  /** Repository-root-relative setup modules for this project's matched tests. */
+  setup_files?: string[];
+  integration_suites?: Record<string, string[]>;
+}
+
 /** Runner accepted by `testsPlan`, `testsTargets`, and `TestExecutionTarget`. */
 export type TestPlanFramework =
   | "vitest"

package/traversal-types.d.ts

@@ -205,4 +205,6 @@ export interface ProjectOptions {
 export interface CheckOptions extends ProjectOptions {
   /** Add deterministic accounting for findings hidden by no-mistakes directives. */
   includeSuppressed?: boolean;
+  /** Add declared config evidence; absent slots never imply SDK defaults. */
+  includeRunnerConfigDeadlines?: boolean;
 }

package/types.d.ts

@@ -4,6 +4,7 @@ export * from "./analyze-project-types";
 export * from "./flow-types";
 export * from "./import-usage-types";
 export * from "./test-types";
+export * from "./test-audit-types";
 export * from "./report-types";
 export * from "./server-contract-types";
 export * from "./ci-types";
@@ -14,3 +15,4 @@ export * from "./mermaid-types";
 export * from "./resolve-config-types";
 export * from "./postgres-query-annotation-types";
 export * from "./planning-impact-artifacts-types";
+export * from "./declared-payload-types";