@cratis/pi 7.129.0 → 7.130.0

package/package/corpus/agents/coordinator.md

@@ -139,7 +139,7 @@ When handing off to a specialist agent:
 For implementation, the applicable changed-lane gates must pass. Mark unrelated entries not applicable; this list is not a full-repository command mandate:
 
 - [ ] `dotnet build` — zero errors, zero warnings
-- [ ] `dotnet test` — all specs pass
+- [ ] Built C# spec executables — all specs pass; `dotnet test <project> --no-build` only for VSTest (see specs.csharp)
 - [ ] `yarn lint` — zero errors (if frontend present)
 - [ ] `npx tsc -b` — zero TypeScript errors (if frontend present)
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates

package/package/corpus/agents/orchestrator.md

@@ -165,7 +165,7 @@ When handing off to any agent or sub-orchestrator:
 For implementation, the applicable changed-lane gates must pass. Mark unrelated entries not applicable; this list is not a full-repository command mandate:
 
 - [ ] `dotnet build` — zero errors, zero warnings
-- [ ] `dotnet test` — all specs pass
+- [ ] Built C# spec executables — all specs pass; `dotnet test <project> --no-build` only for VSTest (see specs.csharp)
 - [ ] `yarn lint` — zero errors (if frontend present)
 - [ ] `npx tsc -b` — zero TypeScript errors (if frontend present)
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates

package/package/corpus/agents/planner.md

@@ -133,7 +133,7 @@ For an implemented application slice, require the applicable changed-lane gates
 - [ ] `dotnet build` succeeds with zero errors and zero warnings
 - [ ] `yarn lint` passes with zero errors (if frontend is present)
 - [ ] `npx tsc -b` passes with zero errors (if frontend is present)
-- [ ] All integration specs pass (`dotnet test`)
+- [ ] All integration specs pass (built C# spec executables; `dotnet test <project> --no-build` only for VSTest; see specs.csharp)
 - [ ] All TypeScript specs pass (`yarn test`) if applicable
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates
 - [ ] `Documentation/verify-markdown.sh` passes when documentation is added or changed

package/package/corpus/harnesses/copilot/instructions/csharp.instructions.md

@@ -13,8 +13,8 @@ The goal is minimal ceremony, maximum clarity. Modern C# (13+) gives us records,
 ## Building
 
 - Use `dotnet build` from the command line.
-- Use `dotnet format` to format code.
-- Use `dotnet test` to run tests.
+- Follow `.editorconfig`; run `dotnet format` only when CI requires it.
+- Run affected spec executables; use `dotnet test <project> --no-build` only for VSTest (see `specs.csharp.md`).
 
 ## Formatting
 

package/package/corpus/harnesses/copilot/instructions/framework.instructions.md

@@ -60,7 +60,7 @@ Repo conventions follow from this: `Source/DotNET` + `Source/JavaScript` for dua
 ## Quality gates (framework)
 
 - Build clean (Debug and Release) with **zero warnings, zero errors**.
-- Specs pass for affected projects (C# via `dotnet test`; TS packages via their test command; Components also `build-storybook`).
+- Specs pass for affected projects (C# spec executables (VSTest only: `dotnet test <project> --no-build`); TS packages via their test command; Components also `build-storybook`).
 - For public-facing changes (APIs, attributes, generated output, component props): update the product documentation and verify it.
 - Match the repo's existing patterns; when a deep architectural question isn't answered by the universal rules or this file, consult the **repo's own docs/CONTRIBUTING** or ask — do not infer framework internals from a single call site.
 

package/package/corpus/harnesses/copilot/instructions/orleans.instructions.md

@@ -63,7 +63,8 @@ using Microsoft.AspNetCore.Builder;
 using MongoDB.Driver;
 
 var builder = WebApplication.CreateBuilder(args);
-const string connectionString = "mongodb://localhost:27017";
+var connectionString = builder.Configuration.GetConnectionString("Mongo")
+    ?? throw new InvalidOperationException("Configure the Mongo connection string.");
 builder.AddCratisOrleans(new CratisOrleansOptions
 {
     ClusterId = "my-service",

package/package/corpus/harnesses/copilot/instructions/pull-requests.instructions.md

@@ -32,6 +32,6 @@ applyTo: "**/*"
 ## Before you create or edit a PR
 
 - Run `node .cratis/ai/hooks/scripts/cratis-check-pr.mjs --body-file <file> --label <intent>`; it applies the exact `policy / verify` release-note rules and the Bash hook runs it on `gh pr create` and `gh pr edit`. If it fails, fix the description, not the code. Before every body edit, run `git diff --stat origin/main...HEAD` and delete bullets the diff no longer supports.
-- Run the affected-project gates before marking work ready (`dotnet build`/`dotnet test` with zero warnings, `yarn lint`, `npx tsc -b`), and the repository's required CI checks after an authorized push. `no-release` and documentation-only PRs still satisfy every required check; none is a blanket exemption from red CI.
+- Run the affected-project gates before marking work ready (build, built specs, lint and type-check; zero warnings), and the repository's required CI checks after an authorized push. `no-release` and documentation-only PRs still satisfy every required check; none is a blanket exemption from red CI.
 - Group small related changes into one branch and one PR; see the skill for consolidation and the release-action windows.
 - Open the PR once, when verified: each push starts CI. One PR per body of work, opened by the orchestrator (`cratis-engineering-release-trains`), with `--assignee @me`.

package/package/corpus/harnesses/copilot/instructions/specs.csharp.instructions.md

@@ -50,7 +50,7 @@ public class when_combining_parts : Specification
 
 The shared lifecycle is the default on xUnit v2 and v3 since 5.0; the package registers the framework, so delete any hand-written `[assembly: Xunit.TestFramework(...)]` (it fails with `CS0579`). Eligible classes derive from `Specification`, have one public constructor with no arguments or only framework-managed fixture arguments, and contain only plain facts. Construction, Establish/Because and Destroy run once; all facts share the instance and must not mutate it. `IDisposable` specifications also share the lifecycle since Cratis.Specifications 4.4.0: one construction and one `Dispose` after the last fact. Initialization failure fails every fact. Theories and `ITestOutputHelper` constructors keep per-fact execution. Keep shared lifecycle on; `[PerFactSpecificationLifecycle]` opts out only the class whose facts genuinely mutate shared state and cannot move the mutation into `Because`. `CRSPEC0008` (a fact modifies the shared context) is an error by default: move the change into `Establish` or `Because`. See the **cratis-specifications-csharp** skill's shared-lifecycle reference.
 
-Run specifications as the built executable, not `dotnet test`: restore and build once, then run `bin/<Config>/net10.0/<Project>.Specs`. In a solution that mixes Microsoft.Testing.Platform and VSTest projects, run each project on its own; `dotnet test` on the whole solution does not work there. Filters and the 4.x → 5.0 checklist are in the **cratis-specifications-csharp** skill's [running-specs reference](../../../skills/cratis-specifications-csharp/references/running-specs.md).
+Run xUnit v3, TUnit and native-runner specifications as each project's built executable: restore and build once, then run its matching configuration/TFM output. Only identified VSTest projects use `dotnet test <project> --no-build`. Never default to solution-wide `dotnet test` in a mixed suite. Filters and the 4.x → 5.0 checklist are in the **cratis-specifications-csharp** skill's [running-specs reference](../../../skills/cratis-specifications-csharp/references/running-specs.md).
 
 CRSPEC0001–CRSPEC0007 are warnings. Since 4.5 the analyzers ship only in `Cratis.Specifications`, transitively used by the framework packages; excluding analyzers on a framework package does not remove them. Derived xUnit/NUnit test attributes are recognized since 4.1.2. `Given`/`When` are aliases since 4.4 (declaring both aliases for one phase is CRSPEC0009), but house style stays `Establish`/`Because`. With warnings as errors, a non-`should_` fact, multiple specs per file (given contexts exempt), a fact on a given context, a `should_` without a test attribute, explicit base lifecycle calls, non-public specs with facts, or `Because` on a given context fail the build. Follow **cratis-specification-by-example**; do not suppress these diagnostics.
 

package/package/corpus/harnesses/pi/agents/coordinator.md

@@ -135,7 +135,7 @@ When handing off to a specialist agent:
 For implementation, the applicable changed-lane gates must pass. Mark unrelated entries not applicable; this list is not a full-repository command mandate:
 
 - [ ] `dotnet build` — zero errors, zero warnings
-- [ ] `dotnet test` — all specs pass
+- [ ] Built C# spec executables — all specs pass; `dotnet test <project> --no-build` only for VSTest (see specs.csharp)
 - [ ] `yarn lint` — zero errors (if frontend present)
 - [ ] `npx tsc -b` — zero TypeScript errors (if frontend present)
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates

package/package/corpus/harnesses/pi/agents/orchestrator.md

@@ -161,7 +161,7 @@ When handing off to any agent or sub-orchestrator:
 For implementation, the applicable changed-lane gates must pass. Mark unrelated entries not applicable; this list is not a full-repository command mandate:
 
 - [ ] `dotnet build` — zero errors, zero warnings
-- [ ] `dotnet test` — all specs pass
+- [ ] Built C# spec executables — all specs pass; `dotnet test <project> --no-build` only for VSTest (see specs.csharp)
 - [ ] `yarn lint` — zero errors (if frontend present)
 - [ ] `npx tsc -b` — zero TypeScript errors (if frontend present)
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates

package/package/corpus/harnesses/pi/agents/planner.md

@@ -129,7 +129,7 @@ For an implemented application slice, require the applicable changed-lane gates
 - [ ] `dotnet build` succeeds with zero errors and zero warnings
 - [ ] `yarn lint` passes with zero errors (if frontend is present)
 - [ ] `npx tsc -b` passes with zero errors (if frontend is present)
-- [ ] All integration specs pass (`dotnet test`)
+- [ ] All integration specs pass (built C# spec executables; `dotnet test <project> --no-build` only for VSTest; see specs.csharp)
 - [ ] All TypeScript specs pass (`yarn test`) if applicable
 - [ ] Public-facing changes (clients, SDKs, public APIs) include associated documentation updates
 - [ ] `Documentation/verify-markdown.sh` passes when documentation is added or changed

package/package/corpus/harnesses/pi/extensions/cratis-hooks/index.ts

@@ -394,7 +394,7 @@ export default function (pi: ExtensionAPI) {
 				const last = latestGateLog(gateLogDirectory(sessionId), started);
 				const tail = last ? tailLines(last.file, TAIL_LINES) : "";
 				throw new Error(`The Cratis quality gate TIMED OUT after ${duration(timeoutSeconds * 1000)}${last ? ` while running '${last.gate}'${last.cwd ? ` (cwd: ${last.cwd})` : ""}` : ""}. This is not a pass: nothing was verified.` +
-					(last ? `\nRun a narrower command instead: ${last.gate === "backend-specs" ? "dotnet test <affected.Specs.csproj-or-Tests.csproj> --configuration Debug --no-build (replace the placeholder; repeat for affected dependents)." : "run the affected project alone using this gate's configured command."}\nConfigure it in .cratis/ai/quality-gates.project.json.\n\nGate log: ${last.file}` : "") +
+					(last ? `\nRun a narrower command instead: ${last.gate === "backend-specs" ? "./<affected-project-dir>/bin/Debug/<TFM>/<AssemblyName> (or dotnet <TargetPath.dll> without apphost); dotnet test <project> --configuration Debug --no-build only for VSTest. Repeat for affected dependents." : "run the affected project alone using this gate's configured command."}\nConfigure it in .cratis/ai/quality-gates.project.json.\n\nGate log: ${last.file}` : "") +
 					(tail ? `\n\n--- last ${TAIL_LINES} lines ---\n${tail}\n--- end ---` : ""));
 			};
 			const reportInterrupted = () => {

package/package/corpus/hooks/README.md

@@ -636,17 +636,29 @@ the script stops the command's process group (TERM, then KILL after one second),
 reports **NOT VERIFIED**, the gate, its directory, log tail, and `timeoutHint` (advice, never executed).
 Commands that create separate sessions/process groups can escape this cleanup; this is not a sandbox.
 
-For a large solution, replace the placeholder below with the affected test project and repeat for
-its affected dependents. Override `command` with that narrower argv array (or a repository-owned
-runner covering all affected projects), rather than raising the timeout without diagnosing the delay:
+The default runs `cratis-run-specs.sh` through the absolute `CRATIS_HOOKS_SCRIPTS_DIR`
+exported by the gate, including nested solutions and bundled Pi installations. The runner
+requires Node, Bash and Git, the same prerequisites as the hooks (not an additional runtime). It evaluates
+MSBuild metadata without building, runs supported built xUnit v3/TUnit/native executables
+(or `dotnet <TargetPath.dll>` without apphost), and uses project-scoped `dotnet test --no-build`
+only for identified VSTest projects. Restore/build matching Debug outputs first. Missing or
+ambiguous metadata/output, custom application entrypoints, failed suites and zero-selected
+suites are not passes; unsupported runners need a repository-owned invocation override.
+
+For a large solution, replace the placeholder below with the affected project directory,
+TFM and AssemblyName and repeat for affected dependents. Use that executable's filter/report
+flags (see [running-specs](../skills/cratis-specifications-csharp/references/running-specs.md)),
+not VSTest logger switches. Override `command` rather than raising a timeout without diagnosis:
 
 ```json
-{ "gates": [{ "id": "backend-specs", "command": ["dotnet", "test", "<affected.Specs.csproj>", "--configuration", "Debug", "--no-build"], "timeoutSeconds": 120, "timeoutHint": "Run dotnet test for each affected Specs/Tests project separately." }] }
+{ "gates": [{ "id": "backend-specs", "command": ["./<project-dir>/bin/Debug/<TFM>/<AssemblyName>"], "timeoutSeconds": 120, "timeoutHint": "Run each affected project's built spec executable separately; dotnet test <project> --configuration Debug --no-build only for VSTest." }] }
 ```
 
 This is not automatic affected-project selection: imported/conditional MSBuild references and
 linked or shared sources require evaluation to establish coverage safely. The default retains
-solution-wide tests rather than silently missing dependents, and a timeout is never a pass.
+all solution projects, executing each test project independently rather than silently missing
+dependents. Non-test projects are explicitly skipped; a solution with none reports no verified
+specifications. A timeout is never a pass. Reports are local under `.ai-work/spec-runs/`.
 
 **Profile note.** The C# patterns are application-profile and scoped to `Source/**/*.cs`, which is
 the application source root [`../rules/general.md`](../rules/general.md) documents. A

package/package/corpus/hooks/pre-commit.md

@@ -26,9 +26,9 @@ Apply before an authorized `git commit`, including `rtk git commit` or `rtk prox
 
 3. **Run specs for each affected .NET project**:
    ```
-   dotnet test <specs-project-path> --no-build
+   ./<project-dir>/bin/<Config>/<TFM>/<AssemblyName>
    ```
-   Use `--no-build` only when matching build outputs are current; otherwise incrementally build the affected specs project first. If the owning specs project cannot be identified, inspect project references or report the uncertainty; do not default to a root-wide test run.
+   Use the project's verified built spec executable (or `dotnet <TargetPath.dll>` without apphost; see [running-specs](../skills/cratis-specifications-csharp/references/running-specs.md)). Only VSTest uses `dotnet test <project> --no-build`. Require current matching outputs; otherwise incrementally build the affected specs project first. If the owning specs project cannot be identified, inspect project references or report the uncertainty; do not default to a root-wide test run.
 
 4. **Run specs for each affected TypeScript project**:
    ```

package/package/corpus/hooks/scripts/cratis-quality-gate.sh

@@ -32,6 +32,7 @@ fi
 
 root="$(hook_repo_root)"
 here="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+export CRATIS_HOOKS_SCRIPTS_DIR="$here"
 config="${CRATIS_HOOKS_GATES:-$here/quality-gates.json}"
 dryrun="${CRATIS_HOOKS_GATE_DRYRUN:-0}"
 

package/package/corpus/hooks/scripts/cratis-run-specs.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Copyright (c) Cratis. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+# Read-only MSBuild evaluation followed by built runners. Children inherit the gate's process group.
+exec node --input-type=module - "$@" <<'NODE'
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+
+function refuse(message) {
+    console.error(`cratis-run-specs: ${message}`);
+    process.exit(1);
+}
+
+const { values } = parseArgs({ args: process.argv.slice(2), options: {
+    project: { type: 'string' }, solution: { type: 'string' }, configuration: { type: 'string', default: 'Debug' },
+    framework: { type: 'string' }, 'no-build': { type: 'boolean' },
+} });
+if (!values['no-build']) refuse('--no-build is required; restore and build once before running specs.');
+if (values.project && values.solution) refuse('Select either --project or --solution, not both.');
+
+function dotnet(arguments_) {
+    const result = spawnSync('dotnet', arguments_, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+    if (result.error || result.status !== 0) refuse(`Metadata evaluation failed: dotnet ${arguments_.join(' ')}\n${result.error?.message ?? result.stderr}`);
+    return result.stdout;
+}
+
+const properties = 'IsTestProject,IsTestingPlatformApplication,UseMicrosoftTestingPlatformRunner,OutputType,TargetPath,TargetFramework,TargetFrameworks,AssemblyName,XunitAutoGeneratedEntryPoint';
+function evaluate(project, framework) {
+    const arguments_ = ['msbuild', project, '-nologo', `-p:Configuration=${values.configuration}`];
+    if (framework) arguments_.push(`-p:TargetFramework=${framework}`);
+    arguments_.push(`-getProperty:${properties}`, '-getItem:PackageReference');
+    try {
+        const metadata = JSON.parse(dotnet(arguments_));
+        if (!metadata.Properties || !Array.isArray(metadata.Items?.PackageReference)) throw new Error('Missing evaluated Properties or PackageReference items');
+        return metadata;
+    } catch (error) {
+        refuse(`Cannot evaluate ${project}: ${error.message}. Restore/build the matching configuration first; configure a repository-owned gate override for unsupported projects.`);
+    }
+}
+
+let projects;
+if (values.project) projects = [resolve(values.project)];
+else {
+    const solutions = values.solution ? [values.solution] : readdirSync('.').filter(name => /\.slnx?$/.test(name));
+    if (solutions.length !== 1) refuse('Expected one solution in the working directory; select --solution or --project explicitly in a gate override.');
+    const solution = resolve(solutions[0]);
+    // Ignore localized headings; accept only actual project entries, relative to the selected solution.
+    projects = dotnet(['sln', solution, 'list']).split(/\r?\n/).map(line => line.trim())
+        .filter(line => /\.(?:cs|fs|vb)proj$/i.test(line)).map(line => resolve(dirname(solution), line.replaceAll('\\', '/')));
+    if (!projects.length) refuse(`No project entries could be established for ${solution}; no specifications verified.`);
+}
+
+function classify(metadata, project) {
+    const properties = metadata.Properties;
+    const packages = new Set(metadata.Items.PackageReference.map(item => String(item.Identity).toLowerCase()));
+    const platform = properties.IsTestingPlatformApplication?.toLowerCase() === 'true';
+    const xunit = ['xunit.v3', 'xunit.v3.core', 'xunit.v3.mtp-off', 'xunit.v3.core.mtp-off',
+        'xunit.v3.mtp-v1', 'xunit.v3.core.mtp-v1', 'xunit.v3.mtp-v2', 'xunit.v3.core.mtp-v2']
+        .some(name => packages.has(name));
+    const native = packages.has('cratis.specifications.runner');
+    const tunit = packages.has('tunit');
+    const legacy = ['xunit', 'nunit', 'mstest.testframework'].some(name => packages.has(name));
+    const test = properties.IsTestProject?.toLowerCase() === 'true' || platform || xunit || native || tunit || legacy;
+    if (!test) return 'non-test';
+    if (properties.XunitAutoGeneratedEntryPoint?.toLowerCase() === 'false') refuse(`${project}: custom application entrypoint; configure a repository-owned spec invocation override (do not start the server).`);
+    if (['exe', 'winexe'].includes(properties.OutputType?.toLowerCase())) {
+        if (xunit && (packages.has('xunit.v3.mtp-off') || packages.has('xunit.v3.core.mtp-off')
+            || properties.UseMicrosoftTestingPlatformRunner?.toLowerCase() !== 'true')) return 'xunit-mtp-off';
+        if (platform || xunit || native || tunit) return 'mtp';
+    }
+    // Test.Sdk can generate an Exe entrypoint for legacy VSTest projects too.
+    if (properties.IsTestProject?.toLowerCase() === 'true' && !platform && !xunit && !native && !tunit && legacy && packages.has('microsoft.net.test.sdk')) return 'vstest';
+    refuse(`${project}: unsupported/unknown test runner; configure a repository-owned backend-specs override instead of falling back to dotnet test.`);
+}
+
+let reportRoot;
+function reportPath() {
+    if (!reportRoot) {
+        const repository = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+        const root = repository.status === 0 ? repository.stdout.trim() : process.cwd();
+        const artifacts = join(root, '.ai-work', 'spec-runs');
+        mkdirSync(artifacts, { recursive: true });
+        reportRoot = mkdtempSync(join(artifacts, 'run-'));
+    }
+    return join(reportRoot, `${executed}.trx`);
+}
+
+function verifyCounts(runner, output, report, project) {
+    let total;
+    let passed;
+    let failed;
+    let skipped;
+    if (runner === 'xunit-mtp-off' && existsSync(report)) {
+        const counters = /<(?:\w+:)?Counters\b([^>]*)\/?\s*>/.exec(readFileSync(report, 'utf8'))?.[1];
+        const count = name => { const value = new RegExp(`\\b${name}="(\\d+)"`).exec(counters ?? ''); return value ? Number(value[1]) : undefined; };
+        total = count('total'); passed = count('passed'); failed = count('failed'); skipped = count('notExecuted') ?? 0;
+    } else if (runner !== 'xunit-mtp-off') {
+        const count = expression => { const match = expression.exec(output); return match ? Number(match[1]) : undefined; };
+        total = count(/\btotal:\s*(\d+)/i);
+        passed = count(/\b(?:succeeded|passed):\s*(\d+)/i);
+        failed = count(/\bfailed:\s*(\d+)/i);
+        skipped = count(/\bskipped:\s*(\d+)/i) ?? 0;
+    }
+    if (total === 0) refuse(`${project}: zero tests executed; no specifications verified.`);
+    if (total === undefined || passed === undefined || failed === undefined) refuse(`${project}: UNVERIFIED — runner count evidence unavailable. Configure a repository-owned invocation with verified reports.`);
+    if (failed !== 0 || passed + skipped !== total || passed === 0) refuse(`${project}: not all specifications passed (total=${total}, passed=${passed}, failed=${failed}).`);
+    console.log(`cratis-run-specs: verified total=${total}, passed=${passed}, failed=${failed}`);
+}
+
+let executed = 0;
+for (const project of projects) {
+    if (!existsSync(project)) refuse(`Solution project does not exist: ${project}`);
+    const initial = evaluate(project);
+    const frameworks = (initial.Properties.TargetFrameworks || initial.Properties.TargetFramework || '').split(';').filter(Boolean);
+    const runner = classify(initial, project);
+    if (runner === 'non-test') { console.log(`cratis-run-specs: SKIP non-test ${project}`); continue; }
+    if (!frameworks.length) refuse(`${project}: target framework unavailable; evaluate the restored project or supply an override.`);
+    if (values.framework && !frameworks.includes(values.framework)) refuse(`${project}: requested framework ${values.framework} not in ${frameworks.join(', ')}.`);
+    for (const framework of values.framework ? [values.framework] : frameworks) {
+        const metadata = initial.Properties.TargetFrameworks ? evaluate(project, framework) : initial;
+        const selectedRunner = classify(metadata, project);
+        if (selectedRunner === 'non-test') refuse(`${project} (${framework}): inconsistent test metadata; no suite may be omitted.`);
+        const target = metadata.Properties.TargetPath;
+        if (!target || !isAbsolute(target)) refuse(`${project}: evaluated TargetPath unavailable; perform the matching ${values.configuration}/${framework} build first.`);
+        const apphost = target.replace(/\.dll$/i, process.platform === 'win32' ? '.exe' : '');
+        const useApphost = apphost !== target && existsSync(apphost);
+        if (!useApphost && !existsSync(target)) refuse(`${project}: missing built output ${target}; perform the matching ${values.configuration}/${framework} build first.`);
+        const report = selectedRunner === 'xunit-mtp-off' ? reportPath() : undefined;
+        const command = selectedRunner === 'vstest' || !useApphost ? 'dotnet' : apphost;
+        const arguments_ = selectedRunner === 'vstest'
+            ? ['test', project, '--configuration', values.configuration, '--no-build', '--framework', framework]
+            : [...(useApphost ? [] : [target]), ...(report ? ['-trx', report] : [])];
+        console.log(`cratis-run-specs: RUN ${project} runner=${selectedRunner} framework=${framework} configuration=${values.configuration}`);
+        const result = spawnSync(command, arguments_, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+        process.stdout.write(result.stdout ?? '');
+        process.stderr.write(result.stderr ?? '');
+        if (result.error) refuse(`${project}: ${result.error.message}`);
+        if (result.status !== 0) process.exit(result.status ?? 1);
+        verifyCounts(selectedRunner, (result.stdout ?? '') + (result.stderr ?? ''), report, project);
+        executed++;
+    }
+}
+console.log(executed ? `cratis-run-specs: verified ${executed} project/framework suite(s).` : 'cratis-run-specs: NO-OP — no test projects; no specifications verified.');
+NODE

package/package/corpus/hooks/scripts/quality-gates.json

@@ -117,9 +117,9 @@
     },
     {
       "id": "backend-specs",
-      "description": "dotnet test (Debug, --no-build) \u2014 zero failures",
+      "description": "Built C# spec executables (Debug, no rebuild); VSTest-only fallback \u2014 zero failures",
       "timeoutSeconds": 120,
-      "timeoutHint": "dotnet test <affected.Specs.csproj-or-Tests.csproj> --configuration Debug --no-build (replace the placeholder with the affected test project; repeat for its affected dependents)",
+      "timeoutHint": "./<affected-project-dir>/bin/Debug/<TFM>/<AssemblyName> (or dotnet <TargetPath.dll> without apphost); only VSTest: dotnet test <project> --configuration Debug --no-build. Repeat for affected dependents.",
       "changed": [
         "**/*.cs",
         "**/*.csproj",
@@ -145,11 +145,9 @@
         "**/*.sln"
       ],
       "command": [
-        "dotnet",
-        "test",
-        "--configuration",
-        "Debug",
-        "--no-build"
+        "bash",
+        "-c",
+        "exec bash \"$CRATIS_HOOKS_SCRIPTS_DIR/cratis-run-specs.sh\" --configuration Debug --no-build"
       ]
     },
     {

package/package/corpus/rules/csharp.md

@@ -12,8 +12,8 @@ The goal is minimal ceremony, maximum clarity. Modern C# (13+) gives us records,
 ## Building
 
 - Use `dotnet build` from the command line.
-- Use `dotnet format` to format code.
-- Use `dotnet test` to run tests.
+- Follow `.editorconfig`; run `dotnet format` only when CI requires it.
+- Run affected spec executables; use `dotnet test <project> --no-build` only for VSTest (see `specs.csharp.md`).
 
 ## Formatting
 

package/package/corpus/rules/framework.md

@@ -59,7 +59,7 @@ Repo conventions follow from this: `Source/DotNET` + `Source/JavaScript` for dua
 ## Quality gates (framework)
 
 - Build clean (Debug and Release) with **zero warnings, zero errors**.
-- Specs pass for affected projects (C# via `dotnet test`; TS packages via their test command; Components also `build-storybook`).
+- Specs pass for affected projects (C# spec executables (VSTest only: `dotnet test <project> --no-build`); TS packages via their test command; Components also `build-storybook`).
 - For public-facing changes (APIs, attributes, generated output, component props): update the product documentation and verify it.
 - Match the repo's existing patterns; when a deep architectural question isn't answered by the universal rules or this file, consult the **repo's own docs/CONTRIBUTING** or ask — do not infer framework internals from a single call site.
 

package/package/corpus/rules/orleans.md

@@ -62,7 +62,8 @@ using Microsoft.AspNetCore.Builder;
 using MongoDB.Driver;
 
 var builder = WebApplication.CreateBuilder(args);
-const string connectionString = "mongodb://localhost:27017";
+var connectionString = builder.Configuration.GetConnectionString("Mongo")
+    ?? throw new InvalidOperationException("Configure the Mongo connection string.");
 builder.AddCratisOrleans(new CratisOrleansOptions
 {
     ClusterId = "my-service",

package/package/corpus/rules/pull-requests.md

@@ -31,6 +31,6 @@ applyTo: "**/*"
 ## Before you create or edit a PR
 
 - Run `node .cratis/ai/hooks/scripts/cratis-check-pr.mjs --body-file <file> --label <intent>`; it applies the exact `policy / verify` release-note rules and the Bash hook runs it on `gh pr create` and `gh pr edit`. If it fails, fix the description, not the code. Before every body edit, run `git diff --stat origin/main...HEAD` and delete bullets the diff no longer supports.
-- Run the affected-project gates before marking work ready (`dotnet build`/`dotnet test` with zero warnings, `yarn lint`, `npx tsc -b`), and the repository's required CI checks after an authorized push. `no-release` and documentation-only PRs still satisfy every required check; none is a blanket exemption from red CI.
+- Run the affected-project gates before marking work ready (build, built specs, lint and type-check; zero warnings), and the repository's required CI checks after an authorized push. `no-release` and documentation-only PRs still satisfy every required check; none is a blanket exemption from red CI.
 - Group small related changes into one branch and one PR; see the skill for consolidation and the release-action windows.
 - Open the PR once, when verified: each push starts CI. One PR per body of work, opened by the orchestrator (`cratis-engineering-release-trains`), with `--assignee @me`.

package/package/corpus/rules/specs.csharp.md

@@ -49,7 +49,7 @@ public class when_combining_parts : Specification
 
 The shared lifecycle is the default on xUnit v2 and v3 since 5.0; the package registers the framework, so delete any hand-written `[assembly: Xunit.TestFramework(...)]` (it fails with `CS0579`). Eligible classes derive from `Specification`, have one public constructor with no arguments or only framework-managed fixture arguments, and contain only plain facts. Construction, Establish/Because and Destroy run once; all facts share the instance and must not mutate it. `IDisposable` specifications also share the lifecycle since Cratis.Specifications 4.4.0: one construction and one `Dispose` after the last fact. Initialization failure fails every fact. Theories and `ITestOutputHelper` constructors keep per-fact execution. Keep shared lifecycle on; `[PerFactSpecificationLifecycle]` opts out only the class whose facts genuinely mutate shared state and cannot move the mutation into `Because`. `CRSPEC0008` (a fact modifies the shared context) is an error by default: move the change into `Establish` or `Because`. See the **cratis-specifications-csharp** skill's shared-lifecycle reference.
 
-Run specifications as the built executable, not `dotnet test`: restore and build once, then run `bin/<Config>/net10.0/<Project>.Specs`. In a solution that mixes Microsoft.Testing.Platform and VSTest projects, run each project on its own; `dotnet test` on the whole solution does not work there. Filters and the 4.x → 5.0 checklist are in the **cratis-specifications-csharp** skill's [running-specs reference](../skills/cratis-specifications-csharp/references/running-specs.md).
+Run xUnit v3, TUnit and native-runner specifications as each project's built executable: restore and build once, then run its matching configuration/TFM output. Only identified VSTest projects use `dotnet test <project> --no-build`. Never default to solution-wide `dotnet test` in a mixed suite. Filters and the 4.x → 5.0 checklist are in the **cratis-specifications-csharp** skill's [running-specs reference](../skills/cratis-specifications-csharp/references/running-specs.md).
 
 CRSPEC0001–CRSPEC0007 are warnings. Since 4.5 the analyzers ship only in `Cratis.Specifications`, transitively used by the framework packages; excluding analyzers on a framework package does not remove them. Derived xUnit/NUnit test attributes are recognized since 4.1.2. `Given`/`When` are aliases since 4.4 (declaring both aliases for one phase is CRSPEC0009), but house style stays `Establish`/`Because`. With warnings as errors, a non-`should_` fact, multiple specs per file (given contexts exempt), a fact on a given context, a `should_` without a test attribute, explicit base lifecycle calls, non-public specs with facts, or `Because` on a given context fail the build. Follow **cratis-specification-by-example**; do not suppress these diagnostics.
 

package/package/corpus/skills/binlog-generation/SKILL.md

@@ -16,7 +16,7 @@ Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, a
 
 You MUST add the `/bl:{}` flag to:
 - `dotnet build`
-- `dotnet test`
+- `dotnet test` when it is the selected VSTest runner; built spec executables do not produce MSBuild binlogs
 - `dotnet pack`
 - `dotnet publish`
 - `dotnet restore`

package/package/corpus/skills/coverage-analysis/references/setup-discovery.md

@@ -202,7 +202,7 @@ if ($testProjects.Count -eq 0) {
 Write-Host "TEST_OUTPUT_ROOT:$testOutputRoot"
 ```
 
-- If `ENTRY_TYPE:NotFound` and SDK-style test projects were found → use the test projects directly as `dotnet test` entry points.
+- If `ENTRY_TYPE:NotFound` and SDK-style test projects were found → pass the selected projects to `run-tests` discovery: supported executable suites use their built runners; only VSTest uses `dotnet test <project> --no-build`.
 - If `ENTRY_TYPE:NotFound` and classic test projects were found → use only the repository's documented coverage command; do not infer `dotnet test`.
 - If `ENTRY_TYPE:NotFound` and no test projects found → stop: `No .sln, .slnx, or test projects found under <path>. Provide the path to your .NET solution, filter, or project.`
 - A missing/unreadable requested path, failed lookup, or ambiguous entry point is a discovery blocker, not measured zero coverage or evidence of an empty suite. Do not continue collection after a discovery error.

package/package/corpus/skills/cratis-application-slice-specifications/SKILL.md

@@ -302,6 +302,6 @@ ideas recorded in `references/provenance.md`. Read `references/provenance.md` wh
 ## How it is proven
 
 `dotnet build -c Debug` — it compiles the `#if DEBUG` specification code — then
-`dotnet test`, both clean, with a specification for the happy path and one per
+the owning project's built spec executable (see [specs.csharp](../../rules/specs.csharp.md)), both clean, with a specification for the happy path and one per
 rejection. Before trusting a rejection specification green, remove the condition
 that causes the rejection once and confirm it goes red.

package/package/corpus/skills/cratis-arc-command-execution/references/command-refusals.md

@@ -59,7 +59,7 @@ These non-refusal failures and unhandled refusals fail the observer for recovery
 ## Verify
 
 Run `dotnet build -c Debug` and the affected specification project with
-`dotnet test`. Cover selector ordering, each handled refusal, unchanged
+the owning project's built spec executable (see [specs.csharp](../../../rules/specs.csharp.md)). Cover selector ordering, each handled refusal, unchanged
 remaining-command collaborators, branch append failure, and a concurrency or
 exception failure that must not be acknowledged. Assert earlier committed effects
 separately; a failed result does not prove rollback.

package/package/corpus/skills/cratis-arc-command-execution/references/occurrence-commands.md

@@ -76,4 +76,4 @@ append behavior. Deliver the same occurrence twice under the same effect name:
 assert one committed effect and a recorded result on the second delivery. Cover
 a terminal refusal, a retryable concurrency conflict, insufficient capability,
 and commit-then-lost-reply recovery. Run the owning specification project with
-`dotnet test`; passing means those assertions ran, not just that compilation succeeded.
+the owning project's built spec executable (see [specs.csharp](../../../rules/specs.csharp.md)); passing means those assertions ran, not just that compilation succeeded.

package/package/corpus/skills/cratis-arc-command-operation/references/testing.md

@@ -237,7 +237,7 @@ not uncertain remote acknowledgments or the external provider's durability.
   `UncompensatedCount`/`FailedCompensationCount`, and remaining callbacks attempted.
 
 Arc's [failure recipes](https://github.com/Cratis/Arc/blob/main/Documentation/backend/csharp/testing/command-operation-failures.md)
-contain the full cases. Run `dotnet test <Your.Specs.csproj>`; assert behavior,
+contain the full cases. Run the owning project's built spec executable (see [specs.csharp](../../../rules/specs.csharp.md)); assert behavior,
 not just command success. These corpus excerpts are source-checked, not compiled
 by the corpus text-verification gate. Test provider ownership, repeated finalized
 requests, conflicting keys, and delayed creates at the provider integration boundary.

package/package/corpus/skills/cratis-arc-command-validation/references/input-binding.md

@@ -61,6 +61,6 @@ Arc can fail to bind such results to the matching form field.
 
 Add specs for offset-less rejection, an accepted offset, malformed input under
 both authorized and denied callers, and nested/indexed member paths. Assert
-server `Members` using camelCase and run `dotnet test` on the owning spec project.
+server `Members` using camelCase and run the owning spec project's built executable (see [specs.csharp](../../../rules/specs.csharp.md)).
 For form behavior, assert the rejection appears on its intended field, not only
 in a command-wide error list.

package/package/corpus/skills/cratis-arc-command-validation/references/validation-severity.md

@@ -18,4 +18,4 @@ remove the floor, and an explicit attribute wins. Check with
 
 Specify both the default refusal and a caller sending a permissive severity.
 Assert the command did not write events; a displayed message alone is not proof
-that validation blocked execution. Run `dotnet test` on the owning spec project.
+that validation blocked execution. Run the owning spec project's built executable (see [specs.csharp](../../../rules/specs.csharp.md)).

package/package/corpus/skills/cratis-chronicle-client-dotnet/references/immediate-append-refusal.md

@@ -36,5 +36,5 @@ In a spec, attempt an immediate append through both the current event log and a
 previously captured reference; assert that neither reaches transport. Assert
 that transactional work commits with its receipt, that an unsupported kernel
 fails closed, and that borrowed frames cannot complete another owner's unit.
-Run `dotnet test` on the owning project. In-process proof is not a substitute for
+Run the owning project's built spec executable (see [specs.csharp](../../../rules/specs.csharp.md)). In-process proof is not a substitute for
 integration coverage of the storage provider's transaction boundary.

package/package/corpus/skills/cratis-chronicle-client-dotnet/references/occurrences.md

@@ -81,7 +81,7 @@ a handler through in-process ingress, claims, receipts and completion:
 
 There are no background workers, automatic lease renewals or reminders in this
 scenario; it does not prove behavior in a real multi-node cluster. Run
-`dotnet test` on the owning spec project and assert duplicate ingress, redelivery,
+the owning spec project's built executable (see [specs.csharp](../../../rules/specs.csharp.md)) and assert duplicate ingress, redelivery,
 terminal refusal, lost reply and unsupported-capability paths.
 
 Requires Chronicle 19.78.0 for `Defaults` and `EventStoreForTesting` constructors

package/package/corpus/skills/cratis-chronicle-event-constraints/references/storage-uniqueness.md

@@ -22,7 +22,7 @@ complete: the first claimant in event-log order retains the value, later duplica
 claims are logged and skipped. Reindexing does not retract their stored events.
 Older kernels can fail the reindex instead.
 
-Run the affected specifications with `dotnet test`, asserting a second source's
+Run the affected specifications with the owning project's built spec executable (see [specs.csharp](../../../rules/specs.csharp.md)), asserting a second source's
 rejection, unchanged original claim after a failed move, and successful reuse
 after release. Real SQL integration must prove two competing claims cannot both
 succeed; an in-memory pass does not prove the SQL index was upgraded.

package/package/corpus/skills/cratis-chronicle-event-specifications/SKILL.md

@@ -229,6 +229,6 @@ assert the value can be claimed again.
 ## How it is proven
 
 `dotnet build` in Debug (which compiles the `#if DEBUG` specification code) and
-`dotnet test`, both clean. A constraint specification is only meaningful if it
+the owning project's built spec executable (see [specs.csharp](../../rules/specs.csharp.md)), both clean. A constraint specification is only meaningful if it
 has been seen to fail: remove the seeding `Given` once and confirm the
 specification goes red before trusting it green.

package/package/corpus/skills/cratis-chronicle-event-type-migration/references/explicit-migrations.md

@@ -41,6 +41,6 @@ the store-local alias. Custom schema generators resolving explicit compensation
 targets need the registry-aware overloads or throw
 `RegistryAwareEventTypeSchemasNotSupported`.
 
-Run `dotnet build -c Debug` and migration specs with `dotnet test`; assert both
+Run `dotnet build -c Debug` and migration spec executables (see [specs.csharp](../../../rules/specs.csharp.md)); assert both
 directions and real observer delivery where pinning or protected-value release
 matters. A successful nomination alone does not prove a generation can be read.

package/package/corpus/skills/cratis-chronicle-reactor/references/starting-and-replaying.md

@@ -29,5 +29,5 @@ handler is still subscribed to.
 
 Verify first registration, restart with an existing position, replay and
 failed-partition redelivery separately. Assert the external effect count, not
-only that the handler was invoked. Run `dotnet test` on the owning spec project;
+only that the handler was invoked. Run the owning spec project's built executable (see [specs.csharp](../../../rules/specs.csharp.md));
 server-first compatibility and durable positions also need kernel integration.

package/package/corpus/skills/cratis-chronicle-read-model/references/collection-observation.md

@@ -41,7 +41,7 @@ pretending observation succeeded.
 
 ## Verify
 
-Run `dotnet build -c Debug` and `dotnet test` for the owning query specs. Cover
+Run `dotnet build -c Debug` and the owning query spec executable (see [specs.csharp](../../../rules/specs.csharp.md)). Cover
 empty, add, update, remove, filter exit and disposal.
 Requires Arc 22.87.0 for Chronicle observations in `QueryScenario`.
 Requires Arc 22.91.1 with Chronicle 19.59.1 for default-mode children/joins/reducers. Scenario rebuilds do

package/package/corpus/skills/cratis-chronicle-read-model-specifications/SKILL.md

@@ -283,6 +283,6 @@ Read `references/view-lifecycle-checks.md` when delivering a read model from a c
 
 ## How it is proven
 
-`dotnet build` in Debug and `dotnet test`, both clean. A projection
+`dotnet build` in Debug and the owning project's built spec executable (see [specs.csharp](../../rules/specs.csharp.md)), both clean. A projection
 specification is only meaningful once it has been seen to fail: drop one seeded
 event and confirm the assertion goes red before trusting it green.

package/package/corpus/skills/cratis-ci-pipeline-performance/SKILL.md

@@ -75,7 +75,7 @@ named reference before applying one.
 **Build once, shard the tests.** Fits execution-bound workflows where build and
 tests run serially or several jobs each rebuild. Default: one job builds in
 `Release`, uploads the output with `actions/upload-artifact`, and a matrix of shard jobs downloads it and runs
-`dotnet test --no-build`. Pitfall: a shard whose filter matches nothing still
+each built spec executable; only VSTest projects use `dotnet test <project> --no-build`. Pitfall: a shard whose filter matches nothing still
 passes, so assert that every shard ran tests. Read
 `references/build-once-and-shard.md` when applying or reviewing this.
 

package/package/corpus/skills/cratis-ci-pipeline-performance/references/build-once-and-shard.md

@@ -75,15 +75,19 @@ jobs:
         with:
           name: build-output
       - run: tar --zstd -xf build-output.tar.zst
+      # Example assumes each xUnit v3 mtp-off AssemblyName matches its directory.
+      # Use evaluated TargetPath for custom outputs; TUnit/native runners need their own report flags.
+      # Only VSTest uses dotnet test <project> --no-build --configuration Release with --logger/--results-directory.
       - name: Test the shard's projects
         env:
           PROJECTS: ${{ matrix.projects }}
         run: |
           failed=0
           for project in $PROJECTS; do
-            dotnet test "$project" --no-build --configuration Release \
-              --logger "trx;LogFileName=$(basename "$project").trx" \
-              --results-directory "$RUNNER_TEMP/test-results" || failed=1
+            mkdir -p "$RUNNER_TEMP/test-results"
+            # xUnit v3 mtp-off example: resolve each project's actual AssemblyName/TFM.
+            "$project/bin/Release/net10.0/$(basename "$project")" \
+              -trx "$RUNNER_TEMP/test-results/$(basename "$project").trx" || failed=1
           done
           exit "$failed"
       - name: Verify every project ran tests

package/package/corpus/skills/cratis-ci-pipeline-performance/references/flaky-and-hung-jobs.md

@@ -24,7 +24,7 @@ cost runner-minutes and developer trust; diagnose before retrying.
 ## Find hangs and crashes in .NET
 
 ```bash
-dotnet test Repo.slnx --configuration Release --no-build \
+dotnet test VSTest.Specs.csproj --configuration Release --no-build \
   --blame-hang --blame-hang-timeout 5m --blame-hang-dump-type mini \
   --blame-crash --blame-crash-dump-type mini \
   --results-directory TestResults

package/package/corpus/skills/cratis-ci-pipeline-performance/references/test-setup-cost.md

@@ -32,7 +32,7 @@ Measure before guessing, with the language's profiler on the test process:
 
 ```bash
 dotnet tool install --global dotnet-trace
-dotnet-trace collect --format speedscope -- dotnet test Project.Specs --no-build --configuration Release
+dotnet-trace collect --format speedscope -- ./<project-dir>/bin/Release/<TFM>/<AssemblyName>
 ```
 
 Read the inclusive time of the setup methods. Pass means the profile names the

package/package/corpus/skills/cratis-commits-and-pull-requests/references/pr-labels-and-release.md

@@ -81,7 +81,7 @@ Documentation-only changes use repository-supported non-release intent, ordinari
 Before marking code/automation work ready, select the affected-project gates that apply from the following list; run wider checks for cross-cutting changes and repository-required merge/release gates:
 
 - `dotnet build`: zero errors, zero warnings
-- `dotnet test`: all specs pass
+- Built C# spec executables: all specs pass; `dotnet test <project> --no-build` only for VSTest (see specs.csharp)
 - `yarn lint`: zero errors
 - `npx tsc -b`: zero TypeScript errors
 - Code follows all project coding standards and conventions

package/package/corpus/skills/cratis-engineering-ci-gates/SKILL.md

@@ -81,8 +81,9 @@ a red run to discover the next failure.
 
 Several agents, worktrees or builds often share one machine. Keep it responsive:
 
-- Cap parallelism, for example `dotnet build -m:2`, `dotnet test -m:2` with the
-  spec runner's thread limit, and `vitest run --maxWorkers=2`.
+- Cap parallelism, for example `dotnet build -m:2`, built spec executables with their
+  runner-specific thread limit, and `vitest run --maxWorkers=2`. Do not pass MSBuild
+  `-m` to executables; `dotnet test <project> --no-build -m:2` is VSTest-only.
 - Run one heavy phase at a time (build, then specs, then frontend lint and
   tests), never several at once.
 - Do not start a heavy phase while another agent's runs in the same machine's

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/SKILL.md

@@ -162,9 +162,13 @@ From the consumer root, with the printed NuGet environment sourced:
 
 ```bash
 dotnet build path/to/consumer.slnx -c Release -warnaserror
-dotnet test path/to/Integration.csproj -c Release --no-build --filter '<regression>'
+./<integration-project-dir>/bin/Release/<TFM>/<AssemblyName> <runner-specific-filter>
 ```
 
+Resolve the integration project's actual built spec entrypoint and filter syntax with
+[running-specs](../cratis-specifications-csharp/references/running-specs.md); without
+apphost use `dotnet <TargetPath.dll>`. Only VSTest uses `dotnet test <project> -c Release
+--no-build --filter '<regression>'`. Keep the sourced local NuGet environment.
 Substitute the repository's actual commands; for frontend fixes run build, lint,
 specs and the previously broken UI action. Pass: the reproducing spec/action now
 succeeds, at least one intended filtered spec actually ran, and the consumer's

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/references/worked-examples.md

@@ -50,10 +50,14 @@ step. Apply the entry point's check/restore/cleanup sequence to both repositorie
    export CHRONICLE_KERNEL_VERSION="$stamp"
    cd "$consumer"
    dotnet build path/to/Studio.slnx -c Release -p:StudioFullBuild=true -warnaserror
-   dotnet test Source/Integrations/Specs/Specs.csproj -c Release --no-build \
-     --filter '<regression>'
+   ./<integration-project-dir>/bin/Release/<TFM>/<AssemblyName> <runner-specific-filter>
    ```
 
+   Resolve the actual output and filter for `Source/Integrations/Specs/Specs.csproj`
+   via [running-specs](../../cratis-specifications-csharp/references/running-specs.md).
+   Without apphost use `dotnet <TargetPath.dll>`; only VSTest uses
+   `dotnet test <project> -c Release --no-build --filter '<regression>'`.
+   Inspect the current consumer workflow before claiming CI equivalence.
    Studio defaults kernel selection to the client version when the environment
    override is absent. Ensure logs show the stamped local image. Local Debug
    Studio builds skip analyzers; use `-p:StudioFullBuild=true` to match CI analyzer
@@ -83,9 +87,11 @@ bash "$local" use-nuget "$arc" "$stamp"
 Gates (Arc `dotnet-build.yml`), run in this order after sourcing the printed env:
 `yarn install --immutable`; in `Source/DotNET/Screenplay.Embedded`: `npm ci --workspaces=false`,
 `npm run typecheck`, `npm test`, `npm run build`; `dotnet build --configuration Release
--p:CratisSpecsTargetFramework=net10.0`; then `dotnet test <project> --no-build --configuration
-Release --framework net10.0` for each project that `python3 scripts/ci-test-shards.py projects
---shard specs-N` prints. Finish by listing Arc's `obj/project.assets.json` files for the stamp.
+-p:CratisSpecsTargetFramework=net10.0`; then each project's evaluated Release/net10.0
+spec executable (or `dotnet <TargetPath.dll>` without apphost) for each project that
+`python3 scripts/ci-test-shards.py projects --shard specs-N` prints. Only identified
+VSTest projects use `dotnet test <project> --no-build --configuration Release --framework
+net10.0`. Inspect the current consumer workflow before claiming equivalence. Finish by listing Arc's `obj/project.assets.json` files for the stamp.
 
 - Pass: the Fundamentals IDs in `project.assets.json` are at the stamp, build has 0 warnings and 0 errors, 18 spec projects run and none fail.
 - Time: pack about 4 min, build about 6 min, the spec projects about 18 min.
@@ -134,9 +140,12 @@ bash "$local" use-nuget "$direct" "$stamp"
 ```
 
 Gates (Direct `build.yml`): `dotnet build Source/Direct/Direct.csproj -c Release
--p:DisableProxyGenerator=true`, the same in Debug with `-warnaserror`, `dotnet test` of that
-project with `--no-build`, and `dotnet test Source/Assurance/Assurance.csproj`. Then
-check `project.assets.json`. Image-based specs also need the producer image tag.
+-p:DisableProxyGenerator=true`, the same in Debug with `-warnaserror`, then the project's
+verified built Debug spec entrypoint. Build `Source/Assurance/Assurance.csproj` in the
+matching configuration and run its verified spec entrypoint too; do not guess assembly
+names or start an application server. See [running-specs](../../cratis-specifications-csharp/references/running-specs.md);
+only VSTest uses `dotnet test <project> --no-build` in that configuration. Inspect the
+current consumer workflow before claiming equivalence. Then check `project.assets.json`. Image-based specs also need the producer image tag.
 
 - Pass for a consumer whose pins lag the producer: every Chronicle ID is in the feed at the
   stamp, the Release build with the owner's floors passes, and `project.assets.json` shows every

package/package/corpus/skills/cratis-orchestration-lanes/references/context-handoff.md

@@ -59,7 +59,7 @@ Cap export retries at five and surface the final failure.
 
 ## Verified facts (with evidence)
 - Cap and spec committed: `git log -1` shows the SHA above.
-- Spec project passes: `dotnet test Source/Export.Specs` exit 0 at that SHA.
+- Spec project passes: `./Source/Export.Specs/bin/Debug/net10.0/Export.Specs` exit 0 at that SHA.
 - Pull request is open: `gh pr list --head export-retry` shows one entry; CI run
   `1234567890` is in progress.
 

package/package/corpus/skills/cratis-orchestration-lanes/references/lane-brief.md

@@ -60,12 +60,12 @@ C# rules.
 **Decisions already made:** the cap is five and is a constant, not
 configuration.
 
-**Gate command:** `dotnet test Source/Export.Specs`.
+**Gate command:** `./Source/Export.Specs/bin/Debug/net10.0/Export.Specs`.
 
 **Done =**
 - [ ] A failing upload stops after five attempts and reports the error
 - [ ] A spec covers the fifth failure and a success on the third attempt
-- [ ] `dotnet test Source/Export.Specs` exits 0
+- [ ] `./Source/Export.Specs/bin/Debug/net10.0/Export.Specs` exits 0
 - [ ] `git diff --stat` shows only the owned files
 
 **Stop and report if:** a public type must change, or another file needs edits.

package/package/corpus/skills/cratis-screenplay-render-and-gap-fill/references/delivery-protocol.md

@@ -33,8 +33,8 @@ per tool call and read each result from its exit status, never from a grep of th
 | Drift or pending-change check | the same command plus `--check` (and `--scope`, `--force` as used) | no write, no recovery: exit 0 current, 6 `changes_pending`, 5 planning failure, refusal or pending recovery |
 | Bundled-binder check | `cratis screenplay validate --executable <root>` | exit 5 with "does not bind into an executable semantic model" when it does not; never renders or writes. Uses the bundled compiler, not the standalone pin |
 | Debug build | `dotnet build <dir>/<Project>.csproj -c Debug` | the build's exit status |
-| Debug tests | `dotnet test <dir>/<Project>.csproj -c Debug --no-build` | the test runner's exit status plus per-test results |
-| List the generated classes | `dotnet test <dir>/<Project>.csproj -c Debug --no-build --list-tests` | the names to map to specifications |
+| Debug tests | `dotnet test <dir>/<Project>.csproj -c Debug --no-build` after the Debug build (Stage-rendered apps use VSTest) | the test runner's exit status plus per-test results |
+| List the generated classes | `dotnet test <dir>/<Project>.csproj -c Debug --no-build --list-tests` | the names to map to specifications; listing is not execution |
 
 `<Project>` is the project name the render used: the `--project-name` value when one was given,
 otherwise the application name. Confirm it from the published `*.csproj` in the destination

package/package/corpus/skills/cratis-screenplay-specifications/SKILL.md

@@ -284,8 +284,9 @@ For view specifications:
 ## Run the specs before calling the work done
 
 Symptom: a model delivered with specifications that were never run. `screenplay test <root>` runs the
-reference evaluator; after a render, run `dotnet test` (Debug) in the destination for the generated
-specification classes. Report both results separately (`cratis-screenplay-toolchain` V4 and V5.tests); a
+reference evaluator; after rendering and building in Debug, run `dotnet test <destination>/<Project>.csproj -c Debug --no-build`
+for the generated specification classes (Stage-rendered apps use VSTest). Run a built spec executable only where spec projects are executables
+(see [specs.csharp](../../rules/specs.csharp.md)). Report both results separately (`cratis-screenplay-toolchain` V4 and V5.tests); a
 build that succeeds is not a test run, and `unbound`/`unsupported` is not a pass.
 
 ## Verify
@@ -293,7 +294,7 @@ build that succeeds is not a test run, and `unbound`/`unsupported` is not a pass
 - [ ] Validate the complete root with warnings as errors, naming tool/version.
       Standalone tool version: `cratis-screenplay-toolchain/SKILL.md`. Run specification examples through
       `screenplay test`; expected unadmitted syntax reports unbound, not passed.
-- [ ] `screenplay test` and, after a render, `dotnet test` were run and their counts reported.
+- [ ] `screenplay test` and, after a Debug render and build, the `dotnet test` above were run and their counts reported.
 - [ ] Executable diagnostics are clean too: `PLAY0350`, `PLAY0352`, `PLAY0388`,
       `PLAY0389` and `PLAY0273` are only reported at binding.
 - [ ] Every slice has at least one boundary specification.

package/package/corpus/skills/cratis-screenplay-toolchain/references/fast-path.md

@@ -24,7 +24,7 @@ Run these in order and stop at the first failure; each step catches what the one
    run one create command and one query, and read the console for errors. The check is the app, not the build:
    a screen reported as `PLAY0269` (deferred from the backend profile, information only) is not evidence that
    it was rendered. List any authored screen that is absent as not rendered; do not call it delivered.
-10. **Specs:** `dotnet test` in `<dir>` (the generated specifications) and `screenplay test <root>`; see
+10. **Specs:** after the Debug build, `dotnet test <dir>/<Project>.csproj -c Debug --no-build` (Stage-rendered apps use VSTest) and `screenplay test <root>`; see
     `cratis-screenplay-specifications`.
 
 The rendered `README.md` repeats steps 6-8 for the pinned scaffold. Re-render and gap-fill rules:

package/package/corpus/skills/cratis-screenplay-toolchain/references/verdicts.md

@@ -227,7 +227,7 @@ results, plus runtime when it was exercised:
 2. **Publication**: what was written, unchanged or refused (`.cratis-render.json`,
    `.cratis-render/journal.json`; `recovered: true` means stop and reconcile).
 3. **Build**: Debug build of the destination (`dotnet build`).
-4. **Tests**: Debug tests of the destination (`dotnet test`). Generated specifications are
+4. **Tests**: After the Debug build, run `dotnet test <destination>/<Project>.csproj -c Debug --no-build` for Stage-rendered apps (VSTest). Use a built spec executable only in repositories whose spec projects really are executables (see [specs.csharp](../../../rules/specs.csharp.md)); never start the rendered app's web-server executable to run specs. Generated specifications are
    compiled in Debug only; map results by generated spec class (`when_<snake>` in namespace
    `<Slice ns>.when_<snake>`, `when_<snake>_is_queried`, `when_<snake>_is_projected`) back to
    the `.play` specification, not by test counts.

package/package/corpus/skills/cratis-specifications-csharp/references/running-specs.md

@@ -11,9 +11,13 @@
 - Filters
 - Migrate from 4.x to 5.0
 
-Requires `Cratis.Specifications.XUnit.v3` 5.0 on `net10.0`. Check the
-`PackageReference` versions in the specification project; 4.x projects follow the
-checklist below before the executable loop applies.
+The xUnit examples and migration checklist require `Cratis.Specifications.XUnit.v3`
+5.0 on `net10.0`. This is not a requirement to migrate frameworks: identify the
+project's evaluated runner first. TUnit and `Cratis.Specifications.Runner` suites
+also run their built executable, with their own help-confirmed flags, not xUnit
+`-trx`/filter flags. Only legacy VSTest projects use `dotnet test <project> --no-build`.
+Check package versions and the actual configuration/TFM; the 4.x migration checklist
+below applies only when migrating, not as a prerequisite to running an existing suite.
 
 Sources: [Running specifications fast](https://github.com/Cratis/Specifications/blob/main/Documentation/running-fast.md),
 [The native runner](https://github.com/Cratis/Specifications/blob/main/Documentation/runner.md) and

package/package/corpus/skills/cratis-stage-rendering-and-sandbox/SKILL.md

@@ -241,7 +241,8 @@ to disk with no managed staging and no safe stale-file removal; a failure can le
   result. State the scope in the V5 report.
 - Report V5 as separate results, each a result or "not run": admission, publication,
   Debug build (`dotnet build <destination>/<Project>.csproj -c Debug`), Debug tests
-  (`dotnet test` on the same project) and runtime. Render alone is the first two.
+  (`dotnet test <destination>/<Project>.csproj -c Debug --no-build` after the build; Stage-rendered apps use VSTest) and runtime. Render alone is the first two.
+  Use a built spec executable only in repositories whose spec projects really are executables (see [specs.csharp](../../rules/specs.csharp.md)); the rendered app's executable starts its web server, not its specs.
 - A refusal is kept verbatim as reported: `PLAY*` (compile or bind), `PLAN-*` (execution
   plan), `STAGE-*` (admission), `CLI-RENDER-*`, or a plain ownership error for a managed
   file. The fix is an intent-preserving model change or a recorded gap, never an edit of

package/package/corpus/skills/cratis-stage-rendering-and-sandbox/references/render-example.md

@@ -119,7 +119,7 @@ Why it is shaped this way:
 | Forced | the same with `--force` | `written: 1`, the rest `unchanged` |
 | Missing name | render without `--name` | exit 5: `A valid --name is required and must be a C# identifier` |
 | Debug build | `dotnet build out/Marina.csproj -c Debug` | succeeds, 0 warnings, 0 errors |
-| Debug tests | `dotnet test out/Marina.csproj -c Debug` | all specification classes pass |
+| Debug tests | `dotnet test out/Marina.csproj -c Debug --no-build` after the Debug build (Stage-rendered apps use VSTest) | all specification classes pass |
 
 Runtime (`docker compose up`, `/healthz`) and the frontend build are separate results.
 

package/package/corpus/skills/csharp-refactoring/SKILL.md

@@ -132,8 +132,8 @@ Use the repo's own build/test workflow when it documents one (`README`/`CONTRIBU
 
 Otherwise:
 ```bash
-dotnet build   # 0 errors
-dotnet test    # stays green; same pass count as before
+dotnet build   # 0 errors; use dotnet test <project> --no-build only for VSTest (see specs.csharp)
+./<project-dir>/bin/<Config>/<TFM>/<AssemblyName> # built spec executable; same discovered/passed counts
 ```
 
 One operation per step; never mix a refactor and a behavior change in the same step. On red, stop and report the failure; repair only your edit without discarding unrelated worktree changes.

package/package/corpus/skills/eliminate-redundant-restores/SKILL.md

@@ -73,7 +73,8 @@ Keep the first restore. Skip a later one only when all four checks pass:
 ### Step 4: Apply the smallest change
 
 - One explicit restore carrying every restore input, then `--no-restore`, `-restore:false` or `--no-build` on later steps.
-- Several `dotnet test` steps over one solution: build once, then `dotnet test --no-build` on each. Add `--no-restore -restore:false` if an rsp enables restore, including on .NET 8 and earlier. `--no-restore` alone still rebuilds.
+- Supported executable suites run their built spec runner instead (see [running-specs](../cratis-specifications-csharp/references/running-specs.md)); the dotnet-test examples here are VSTest-only.
+- Several `dotnet test` steps over one VSTest-only solution: build once, then `dotnet test --no-build` on each. Add `--no-restore -restore:false` if an rsp enables restore, including on .NET 8 and earlier. `--no-restore` alone still rebuilds.
 - Keep self-contained publish settings. A `publish --no-build` still needs a prior build with matching configuration, framework, RID and self-contained output; restore compatibility does not prove that build outputs exist.
 - Scope the change to CI and scripts. Leave `-restore` in `Directory.Build.rsp`, because developers rely on it; pass `-restore:false` per invocation instead.
 - Never remove the first restore. If it is a `--locked-mode` gate, keep it there.

package/package/corpus/skills/filter-syntax/SKILL.md

@@ -11,7 +11,7 @@ metadata:
 
 # Test Filter Syntax Reference
 
-Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ. Specification authoring belongs to **cratis-specifications-csharp**; Cratis core repositories run xUnit v2 on VSTest.
+Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ. Specification authoring belongs to **cratis-specifications-csharp**; identify the actual runner rather than assuming xUnit v2/VSTest. Supported Cratis executable suites use direct runner flags first (see its [running-specs reference](../cratis-specifications-csharp/references/running-specs.md)). The dotnet-test forms below are technical syntax when that entrypoint is explicitly required, not the Cratis default.
 
 Filter syntax depends on the **platform** and **test framework**.
 

package/package/corpus/skills/msbuild/references/build-perf-baseline.md

@@ -408,9 +408,12 @@ dotnet restore
 if ($LASTEXITCODE -ne 0) { throw "Restore failed; do not use stale assets." }
 dotnet build --no-restore -m
 if ($LASTEXITCODE -ne 0) { throw "Build failed; do not test stale outputs." }
-dotnet test --no-build
+./<project-dir>/bin/<Config>/<TFM>/<AssemblyName> # built spec executable
 ```
 
+Use the evaluated output without rebuilding (see [running-specs](../../cratis-specifications-csharp/references/running-specs.md));
+only VSTest uses `dotnet test <project> --no-build`. The executable step itself
+produces no MSBuild binlog.
 Use matching configuration/TFM/RID and restore-affecting properties in each stage.
 `--no-restore` requires current assets; `--no-build` requires successfully built
 matching test outputs. Keep restore-inclusive and build-only timings separate.

package/package/corpus/skills/run-tests/SKILL.md

@@ -88,6 +88,15 @@ resolved. Route identification-only requests to `platform-detection`.
 
 ## Decision table
 
+For supported Cratis xUnit v3, TUnit and native-runner suites, restore/build once
+and run each project's built executable directly, or `dotnet <TargetPath.dll>`
+when there is no apphost. Use the matching configuration/TFM and runner-specific
+filter/report flags; see [running-specs](../cratis-specifications-csharp/references/running-specs.md).
+Only identified VSTest projects default to `dotnet test <project> --no-build`.
+Mixed suites run per project, never solution-wide `dotnet test`. The command-mode
+forms below remain valid when the user explicitly requires dotnet-test syntax;
+do not switch an executable suite to them as an automatic fallback.
+
 | Detected mode / platform | Command shape | Never use |
 |---|---|---|
 | Classic non-SDK | Repository script, or full MSBuild followed by `vstest.console.exe` / `MSTest.exe` | Assuming `dotnet test` is compatible or migrating implicitly |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratis/pi",
-  "version": "7.129.0",
+  "version": "7.130.0",
   "description": "Configuration-aware Cratis AI integration for Pi",
   "type": "module",
   "files": [