@cratis/pi 7.129.0 → 7.131.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/browser.instructions.md

@@ -16,8 +16,10 @@ Authority in [`general.md`](../../../rules/general.md). Read this before any bro
   request or an applicable policy names that exact action. A configured browser tool is not
   a permit.
 - **[contract] One production tab per session.** No parallel polling or parallel findings on
-  production. Run the health check first, close idle browsers, and look for stale tabs from
-  other sessions before opening one.
+  production. Run the health check first and close your own idle pages before opening one.
+- **[contract] Close only what you opened.** Promptly close the browser backend you
+  started; if no shutdown tool exists, close your pages and report it. Subagents do the
+  same. Never touch a user's or shared session; no `pkill`/`killall`. One browser per lane.
 - **[convention] Prefer staging or a local copy** for interactive and visual smoke runs.
 - **[contract] Only the `browser-operator` agent receives browser tools.** Hand it the URL,
   scope, permit and artifact directory. The main session does not do browser work itself

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,5 @@ 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.
-- 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`.
+- 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.
+- The release train is the PR: fold finished branches into the repository's one train (see the skill). Open it once, when verified, as the orchestrator (`cratis-engineering-release-trains`) with `--assignee @me`. Split only for a named major, an urgent security fix authorized in writing, or an accepted outsider issue (patch or minor, own release).

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/browser.md

@@ -15,8 +15,10 @@ Authority in [`general.md`](./general.md). Read this before any browser call.
   request or an applicable policy names that exact action. A configured browser tool is not
   a permit.
 - **[contract] One production tab per session.** No parallel polling or parallel findings on
-  production. Run the health check first, close idle browsers, and look for stale tabs from
-  other sessions before opening one.
+  production. Run the health check first and close your own idle pages before opening one.
+- **[contract] Close only what you opened.** Promptly close the browser backend you
+  started; if no shutdown tool exists, close your pages and report it. Subagents do the
+  same. Never touch a user's or shared session; no `pkill`/`killall`. One browser per lane.
 - **[convention] Prefer staging or a local copy** for interactive and visual smoke runs.
 - **[contract] Only the `browser-operator` agent receives browser tools.** Hand it the URL,
   scope, permit and artifact directory. The main session does not do browser work itself

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/general.md

@@ -63,9 +63,9 @@ obtaining credentials, and other local conventions ("Product policy" above).
 
 Default to agentic behavior: inspect local rules, skills, code, tests, and generated patterns; make conservative assumptions supported by that context; implement and verify end to end when feasible. A user's direct request authorizes every clearly named in-scope action, including external effects such as pushing, opening or merging a pull request, applying the requested label, deployment, issue mutation, and operations against a named environment. The user is the authority for their request; do not require them to identify another approver, decision record, or formal operation profile.
 
-Don't interrupt with questions the repository can answer. Make reversible implementation choices and report them rather than asking the user to approve an implementation plan they already asked you to carry out. Once the user authorizes an action, do not ask them to authorize it again unless the target or consequence materially changes. Ask only when the answer can't be found locally, reasonable product or domain choices have meaningfully different consequences, a consequential effect was not included in the request, the change is hard to reverse and its scope is unclear, or the user asked for checkpoints.
+Decide what the repository or research can answer, record the evidence, and get a cross-provider check when the decision is risky. Report reversible choices instead of asking approval for a plan the user requested; do not re-ask for an authorized action unless its target or consequence materially changes. Deciding never widens the task's authorization ([capability-is-not-authority.md](./capability-is-not-authority.md)). Ask only about human-only matters (credentials, money, production access, legal, merging majors), undecided product choices with different consequences, an effect the request did not include, a hard-to-reverse change with unclear scope, or requested checkpoints.
 
-When a question is necessary, write it for the person doing the work, not for the governance system: explain the concrete choice, why it matters now, the consequence of each option, and the recommended option in plain language. Never present unexplained internal labels such as "execution authority," "capability contract," "delegation architecture," "operation profile," or "decider." Do not bundle unrelated verdicts. Ask who should be named in a durable decision record only after explaining that a significant decision has been made and why preserving it is warranted; a decision record is never a prerequisite for carrying out the user's direct request.
+Write a necessary question plainly: the choice, why now, each option's consequence, your recommendation. No unexplained internal labels ("execution authority," "operation profile," "decider"); do not bundle verdicts. A decision record never gates a direct request; offer one only after explaining the decision.
 
 ## Destructive operations
 

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,5 @@ 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.
-- 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`.
+- 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.
+- The release train is the PR: fold finished branches into the repository's one train (see the skill). Open it once, when verified, as the orchestrator (`cratis-engineering-release-trains`) with `--assignee @me`. Split only for a named major, an urgent security fix authorized in writing, or an accepted outsider issue (patch or minor, own release).

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.