From e3473ed715757e055b78fc694bae80bace9b5528 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 19 Oct 2026 02:22:06 +0000
Subject: [PATCH 1/2] fix(dogfood): fail no-work copilot runs and skip
 versionless pins

A run whose every agent output is the no-work placeholder now reports
failure instead of success. Central-management opt-out drops the versionless
audit package references before restore, and the brick guide names
IBrickRegistry.GetBrick.

Co-authored-by: icfrelinger <icfrelinger@gmail.com>
---
 Directory.Build.targets                       | 14 ++++
 .../Ashlar.API/Endpoints/AshlarEndpoints.cs   |  9 +-
 docs/TesterQuickstart.md                      |  2 +-
 docs/knowledge-graph.json                     |  4 +-
 docs/knowledge-graph.md                       |  2 +-
 docs/sdk.md                                   |  2 +-
 .../Agents/GenericAgent.cs                    | 32 +++++++
 .../Coordination/Orchestrator.cs              | 19 ++++-
 ...chestrationOrchestratorGapCoverageTests.cs | 54 ++++++++++++
 .../central-management-opt-out.test.sh        | 84 +++++++++++++++++++
 10 files changed, 214 insertions(+), 8 deletions(-)
 create mode 100644 tests/scripts/central-management-opt-out.test.sh

diff --git a/Directory.Build.targets b/Directory.Build.targets
index 982968d74..62a71f824 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -41,6 +41,20 @@
     <NoWarn>$(NoWarn);ASHLAREXP002</NoWarn>
   </PropertyGroup>
 
+  <!-- Directory.Build.props adds versionless System.Text.Encodings.Web and
+       System.Text.RegularExpressions references so central package management can lift the
+       vulnerable transitives. That file is imported before the project body, so it cannot see a
+       project that sets ManagePackageVersionsCentrally to false. Leaving the versionless items
+       in place is NU1015. Metadata conditions are illegal outside a target (MSB4190/MSB4191),
+       so the drop runs here, before NuGet collects references. A project that pins its own
+       Version keeps that pin. -->
+  <Target Name="AshlarDropVersionlessAuditOverrides" BeforeTargets="CollectPackageReferences">
+    <ItemGroup Condition="'$(ManagePackageVersionsCentrally)' == 'false'">
+      <PackageReference Remove="System.Text.Encodings.Web" Condition="'%(PackageReference.Version)' == ''" />
+      <PackageReference Remove="System.Text.RegularExpressions" Condition="'%(PackageReference.Version)' == ''" />
+    </ItemGroup>
+  </Target>
+
   <!-- NetStandard compatibility shims (Unity 2019+): required members, init-only, etc.
        Evaluated statically (not inside a <Target>) so IDE/language-server design-time builds
        also see the polyfills; a Target-added <Compile> item is invisible to design-time builds,
diff --git a/application/src/Ashlar.API/Endpoints/AshlarEndpoints.cs b/application/src/Ashlar.API/Endpoints/AshlarEndpoints.cs
index 7730ac339..28dd5b7f1 100644
--- a/application/src/Ashlar.API/Endpoints/AshlarEndpoints.cs
+++ b/application/src/Ashlar.API/Endpoints/AshlarEndpoints.cs
@@ -1481,7 +1481,8 @@ private static bool TryResolveProductTenant(
             return summary;
 
         var safeToForward = IsDevelopment()
-            || string.Equals(last.IssueType, BarrierContextMissingIssueType, StringComparison.Ordinal);
+            || string.Equals(last.IssueType, BarrierContextMissingIssueType, StringComparison.Ordinal)
+            || string.Equals(last.IssueType, NoWorkPlaceholderIssueType, StringComparison.Ordinal);
         return safeToForward
             ? $"{summary}: {last.Description}"
             : $"{summary}: see escalations ({last.IssueType})";
@@ -1493,6 +1494,12 @@ private static bool TryResolveProductTenant(
     /// </summary>
     private const string BarrierContextMissingIssueType = "BARRIER_CONTEXT_MISSING";
 
+    /// <summary>
+    /// Mirrors the orchestrator's no-work escalation. The description is static (no exception
+    /// text), so it is safe to put on the receipt outside Development.
+    /// </summary>
+    private const string NoWorkPlaceholderIssueType = "NO_WORK";
+
     // The escalation issue type is the closest thing to a canonical code the orchestrator
     // emits (BarrierContextMissingException escalates under its own ErrorCode).
     private static string? ResolveOrchestrationErrorCode(OrchestrationResult result) =>
diff --git a/docs/TesterQuickstart.md b/docs/TesterQuickstart.md
index e0a49edda..ccd2c840f 100644
--- a/docs/TesterQuickstart.md
+++ b/docs/TesterQuickstart.md
@@ -70,7 +70,7 @@ $r | Select-Object taskId, success, summary
 
 The route is `POST /api/copilot/task` (`application/src/Ashlar.API/Endpoints/AshlarEndpoints.cs`); the body is `CopilotTaskRequest(string Task, int AuditCount = 25)` (`application/src/Ashlar.API/Endpoints/CopilotTaskRequest.cs`). The response is `CopilotTaskResponse`: `taskId`, `tenantId` (`default` unless you send `X-Ashlar-Tenant`), `success`, `summary` (for example `1 agent(s) executed`), `output` (per-agent results), `isTrustPaused`, and `recentAudit`. Two things to know when reading it:
 
-- With the mock provider the `output` text is deterministic scaffolding (a "fallback decomposition"), not model output. The point of this page is the **record**, not the prose. To route to a real model, set `ASHLAR_OLLAMA_BASE_URL` / `OPENAI_API_KEY` instead of `ASHLAR_ALLOW_MOCK` (see `docs/Configuration.md`).
+- With the mock provider the `output` text is deterministic scaffolding (a "fallback decomposition"), not model output. The point of this page is the **record**, not the prose. When that scaffolding is only the no-work placeholder (`placeholder: true`, no specialized agent), `success` is false and the audit disposition is `Failure`. To route to a real model, set `ASHLAR_OLLAMA_BASE_URL` / `OPENAI_API_KEY` instead of `ASHLAR_ALLOW_MOCK` (see `docs/Configuration.md`).
 - ~~`recentAudit` holds the entries recorded **before** this task (the handler snapshots the log, then records the task), so it is `[]` on your first call and shows the previous task on the second.~~ **[Fixed 2026-09-20]** `recentAudit` now includes this task's audit entry — the handler logs the task entry before reading the recent audit, so your first call shows the `CopilotTask` entry immediately.
 
 Now read the trail the task left:
diff --git a/docs/knowledge-graph.json b/docs/knowledge-graph.json
index a0cd27b41..1762f1b90 100644
--- a/docs/knowledge-graph.json
+++ b/docs/knowledge-graph.json
@@ -16,7 +16,7 @@
     "operator_vars_missing_from_configuration_reference": 17,
     "operator_vars_absent_from_all_documentation": 0,
     "test_files_declaring_facts": 811,
-    "declared_facts": 5207,
+    "declared_facts": 5209,
     "workflows": 61
   },
   "operator_vars_missing_from_configuration_reference": [
@@ -8088,7 +8088,7 @@
       "file": "src/Ashlar.Tests.Orchestration/OrchestrationOrchestratorGapCoverageTests.cs",
       "project": "Ashlar.Tests.Orchestration",
       "namespace": "Ashlar.Tests.Orchestration",
-      "declared_facts": 19,
+      "declared_facts": 21,
       "in_cert_gate_filter": false
     },
     {
diff --git a/docs/knowledge-graph.md b/docs/knowledge-graph.md
index 15408e079..649642445 100644
--- a/docs/knowledge-graph.md
+++ b/docs/knowledge-graph.md
@@ -20,7 +20,7 @@ remembered to update — staleness here is a red build.
 | missing from `docs/Configuration.md` | 17 |
 | **mentioned in no document at all** | **0** |
 | test files declaring xUnit facts | 811 |
-| declared facts | 5207 |
+| declared facts | 5209 |
 | workflows | 61 |
 
 ## Namespaces cert-gate selects
diff --git a/docs/sdk.md b/docs/sdk.md
index e658e7b41..380b77d09 100644
--- a/docs/sdk.md
+++ b/docs/sdk.md
@@ -106,7 +106,7 @@ sdk.RegisterBrick<OWASPScannerBrick>();
 sdk.RegisterBrick<MySecurityBrick>();
 ```
 
-Bricks are resolved via dependency injection when instantiated. Ensure required services (e.g. `IProviderFactory`) are registered.
+Resolve a registered brick with `IBrickRegistry.GetBrick`. `AddAshlarBrick<T>()` adds the type to that registry; it does not register `T` as its own service. Ensure required services (e.g. `IProviderFactory`) are registered.
 
 ## RegisterAgent&lt;T&gt;
 
diff --git a/src/Ashlar.Orchestration/Agents/GenericAgent.cs b/src/Ashlar.Orchestration/Agents/GenericAgent.cs
index a2d26ea37..f0a67f741 100644
--- a/src/Ashlar.Orchestration/Agents/GenericAgent.cs
+++ b/src/Ashlar.Orchestration/Agents/GenericAgent.cs
@@ -68,3 +68,35 @@ protected override Task OnShutdownAsync(CancellationToken cancellationToken)
     }
 }
 
+/// <summary>
+/// A no-work fallback is still a successful agent call (the transport delivered it). The
+/// orchestration result is a different flag: when every output is one of these, the run
+/// performed no work and must not report success.
+/// </summary>
+internal static class NoWorkPlaceholder
+{
+    internal static bool Is(object? output)
+    {
+        if (output is null)
+            return false;
+
+        var property = output.GetType().GetProperty("Placeholder");
+        return property is { CanRead: true, PropertyType: var type }
+            && type == typeof(bool)
+            && property.GetValue(output) is true;
+    }
+
+    internal static bool Only(IEnumerable<object> outputs)
+    {
+        var any = false;
+        foreach (var output in outputs)
+        {
+            any = true;
+            if (!Is(output))
+                return false;
+        }
+
+        return any;
+    }
+}
+
diff --git a/src/Ashlar.Orchestration/Coordination/Orchestrator.cs b/src/Ashlar.Orchestration/Coordination/Orchestrator.cs
index 6c41d2970..21ff696ba 100644
--- a/src/Ashlar.Orchestration/Coordination/Orchestrator.cs
+++ b/src/Ashlar.Orchestration/Coordination/Orchestrator.cs
@@ -490,12 +490,27 @@ await _barrierGuard.AssertValidForInvocationAsync(
                 : null;
             var integratedOutput = _outputIntegrator.Integrate(decomposition.Agents, outputs);
 
+            // GenericAgent's transport result stays Success (the call completed). A run whose every
+            // output is that no-work placeholder did not do the task; reporting it as success is
+            // the silent green receipt. Escalate under a static code so the API summary can say
+            // why outside Development, the same way a missing barrier does.
+            var noWork = NoWorkPlaceholder.Only(outputs.Values);
+            if (noWork)
+            {
+                _escalationManager.EscalateIssue(
+                    "NO_WORK",
+                    "No specialized agent performed work; the result is a placeholder.",
+                    EscalationSeverity.High);
+            }
+
+            var success = integratedOutput.IsValid && !noWork;
+
             // Step 6: Shutdown all agents
             await _lifecycleManager.ShutdownAllAsync(cancellationToken);
 
             if (rootSpanId != null)
             {
-                _metrics?.EndSpan(rootSpanId, integratedOutput.IsValid, new Dictionary<string, string>
+                _metrics?.EndSpan(rootSpanId, success, new Dictionary<string, string>
                 {
                     ["agentCount"] = decomposition.Agents.Count.ToString(),
                     ["conflictCount"] = conflicts.Count.ToString(),
@@ -505,7 +520,7 @@ await _barrierGuard.AssertValidForInvocationAsync(
 
             return new OrchestrationResult
             {
-                Success = integratedOutput.IsValid,
+                Success = success,
                 IntegratedOutput = integratedOutput,
                 Decomposition = decomposition,
                 Conflicts = conflicts,
diff --git a/src/Ashlar.Tests.Orchestration/OrchestrationOrchestratorGapCoverageTests.cs b/src/Ashlar.Tests.Orchestration/OrchestrationOrchestratorGapCoverageTests.cs
index 6357564e4..1a3a33737 100644
--- a/src/Ashlar.Tests.Orchestration/OrchestrationOrchestratorGapCoverageTests.cs
+++ b/src/Ashlar.Tests.Orchestration/OrchestrationOrchestratorGapCoverageTests.cs
@@ -558,6 +558,60 @@ public async Task OrchestrateAsync_surfaces_missing_barrier_context_as_a_distinc
             Times.Never);
     }
 
+    [Fact]
+    public async Task OrchestrateAsync_reports_failure_when_every_output_is_a_no_work_placeholder()
+    {
+        var transportMock = new Mock<IAgentTransport>();
+        transportMock
+            .Setup(t => t.SendAsync(It.IsAny<AgentInvocationRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AgentResult(
+                Success: true,
+                Output: new { Placeholder = true, Output = "No specialized agent performed work" }));
+
+        var decomposition = new DecompositionResult
+        {
+            OriginalRequest = "what is 2 + 2",
+            Agents = [new AgentSpawnSpec { AgentId = "fallback-1", Domain = "Gameplay", Goal = "Handle request" }],
+        };
+
+        var sut = CreateOrchestrator(CreateArchitectMock(decomposition).Object, transportMock.Object);
+        var result = await sut.OrchestrateAsync("what is 2 + 2");
+
+        result.Success.Should().BeFalse();
+        result.IntegratedOutput!.AgentOutputs.Should().ContainKey("fallback-1");
+        var escalation = result.Escalations.Should().ContainSingle().Subject;
+        escalation.IssueType.Should().Be("NO_WORK");
+        escalation.Description.Should().Be("No specialized agent performed work; the result is a placeholder.");
+    }
+
+    [Fact]
+    public async Task OrchestrateAsync_stays_successful_when_a_real_output_sits_beside_a_placeholder()
+    {
+        var transportMock = new Mock<IAgentTransport>();
+        transportMock
+            .Setup(t => t.SendAsync(It.Is<AgentInvocationRequest>(r => r.AgentName == "fallback-1"), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AgentResult(Success: true, Output: new { Placeholder = true, Output = "no work" }));
+        transportMock
+            .Setup(t => t.SendAsync(It.Is<AgentInvocationRequest>(r => r.AgentName == "real-1"), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AgentResult(Success: true, Output: new { ok = true }));
+
+        var decomposition = new DecompositionResult
+        {
+            OriginalRequest = "mixed",
+            Agents =
+            [
+                new AgentSpawnSpec { AgentId = "fallback-1", Domain = "Gameplay", Goal = "Handle request" },
+                new AgentSpawnSpec { AgentId = "real-1", Domain = "Security", Goal = "Check" },
+            ],
+        };
+
+        var sut = CreateOrchestrator(CreateArchitectMock(decomposition).Object, transportMock.Object);
+        var result = await sut.OrchestrateAsync("mixed");
+
+        result.Success.Should().BeTrue();
+        result.Escalations.Should().BeEmpty();
+    }
+
     [Fact]
     public async Task OrchestrateAsync_defaults_to_floor_barrier_when_context_missing_and_not_required()
     {
diff --git a/tests/scripts/central-management-opt-out.test.sh b/tests/scripts/central-management-opt-out.test.sh
new file mode 100644
index 000000000..9fb00e0f0
--- /dev/null
+++ b/tests/scripts/central-management-opt-out.test.sh
@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Directory.Build.props injects versionless PackageReferences for the two audit overrides
+# (System.Text.Encodings.Web, System.Text.RegularExpressions). A project that sets
+# ManagePackageVersionsCentrally to false has no central version for them, and restore
+# fails NU1015. The props file is imported before the project body, so the skip lives in
+# Directory.Build.targets, which runs after that property is set: drop only the versionless
+# copies of those two packages. A project that leaves central management on still receives
+# them. A project that pins its own Version keeps that pin.
+#
+# Run:  bash tests/scripts/central-management-opt-out.test.sh
+# Pure bash + python3: no network, no dotnet, no container.
+
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+PASS=0
+FAIL=0
+ok()  { PASS=$((PASS + 1)); echo "  ok   — $1"; }
+bad() { FAIL=$((FAIL + 1)); echo "  FAIL — $1"; echo "         $2"; }
+
+python3 - "${ROOT}/Directory.Build.props" "${ROOT}/Directory.Build.targets" << 'PY'
+import sys
+import xml.etree.ElementTree as ET
+
+NS = {"m": "http://schemas.microsoft.com/developer/msbuild/2003"}
+AUDIT = ("System.Text.Encodings.Web", "System.Text.RegularExpressions")
+
+def load(path):
+    # The repo files omit the MSBuild namespace. Keep the parser strict about that.
+    text = open(path, encoding="utf-8").read()
+    if "schemas.microsoft.com/developer/msbuild/2003" in text:
+        raise SystemExit(f"unexpected default namespace in {path}")
+    return ET.parse(path).getroot()
+
+props = load(sys.argv[1])
+targets = load(sys.argv[2])
+
+injected = []
+for group in props.findall("ItemGroup"):
+    for ref in group.findall("PackageReference"):
+        name = ref.get("Include")
+        if name in AUDIT:
+            injected.append((name, ref.get("Version"), group.get("Condition")))
+
+if [name for name, _, _ in injected] != list(AUDIT):
+    raise SystemExit(f"props no longer injects exactly the two audit overrides: {injected}")
+if any(version for _, version, _ in injected):
+    raise SystemExit(f"audit overrides must stay versionless in props: {injected}")
+print("ok props injects the two versionless audit overrides")
+
+drops = [
+    t for t in targets.findall("Target")
+    if t.get("Name") == "AshlarDropVersionlessAuditOverrides"
+]
+if len(drops) != 1:
+    raise SystemExit(f"expected one AshlarDropVersionlessAuditOverrides target, found {len(drops)}")
+target = drops[0]
+before = target.get("BeforeTargets") or ""
+if "CollectPackageReferences" not in before:
+    raise SystemExit(f"drop target must run before NuGet collects references: {before}")
+removes = []
+for group in target.findall("ItemGroup"):
+    cond = group.get("Condition") or ""
+    for ref in group.findall("PackageReference"):
+        removes.append((cond, ref.get("Remove"), ref.get("Condition") or ""))
+if not removes or "'$(ManagePackageVersionsCentrally)' == 'false'" not in removes[0][0]:
+    raise SystemExit(f"Remove group is not gated on central management off: {removes}")
+by_name = {name: cond for _, name, cond in removes}
+if set(by_name) != set(AUDIT):
+    raise SystemExit(f"Remove must name exactly the two audit overrides: {removes}")
+for name, item_cond in by_name.items():
+    if item_cond != "'%(PackageReference.Version)' == ''":
+        raise SystemExit(f"{name} remove must keep a project that pins Version: {item_cond}")
+print("ok targets drops only the versionless audit overrides when central management is off")
+PY
+PY_RC=$?
+if [[ "${PY_RC}" -eq 0 ]]; then
+  ok "versionless audit overrides are skipped when central management is off"
+else
+  bad "central-management opt-out" "checker exited ${PY_RC}"
+fi
+
+echo "central-management-opt-out: ${PASS} passed, ${FAIL} failed"
+[[ "${FAIL}" -eq 0 ]]

From 7768c57ae8de9e1c148eddc4443deefe61c86dfc Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 19 Oct 2026 02:42:59 +0000
Subject: [PATCH 2/2] fix(uat): expect the no-work copilot receipt

The mock task is success false with the placeholder summary. Tier 1 and
tier 10 still required success true, so the API lanes went red. Tier 10
still fails the shared-agent Executing crash.

Co-authored-by: icfrelinger <icfrelinger@gmail.com>
---
 tests/uat/README.md  |  3 +++
 tests/uat/tier0-2.sh | 13 ++++++++++---
 tests/uat/tier10.sh  | 25 +++++++++++++++++++------
 3 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/tests/uat/README.md b/tests/uat/README.md
index de3538276..0a014c624 100644
--- a/tests/uat/README.md
+++ b/tests/uat/README.md
@@ -143,3 +143,6 @@ meant remapping dependency edges, execution order, outputs and the integrator co
 
 Fixing any one of the three alone looks like success to a check that counts HTTP 200s. Tier 10 asks
 whether the **work reached the record**, which is why it kept failing until all three were gone.
+The mock fallback still performs no work, so a finished run is `success: false` with the no-work
+summary. Tier 10 counts those receipts. It still fails a body that says `cannot execute from state
+Executing`, which is the shared-agent crash and not the placeholder.
diff --git a/tests/uat/tier0-2.sh b/tests/uat/tier0-2.sh
index 82227e760..8558e76cd 100644
--- a/tests/uat/tier0-2.sh
+++ b/tests/uat/tier0-2.sh
@@ -226,10 +226,17 @@ R=$(curl -s --max-time 300 "$API/api/copilot/task" -H "Content-Type: application
 TASK_S=$(( $(now) - t0 ))
 echo "$R" >"$OUT/task.json"
 TASK_ID=$(printf '%s' "$R" | grep -o '"taskId":"[^"]*"' | head -1 | cut -d'"' -f4)
-if [ -n "$TASK_ID" ] && printf '%s' "$R" | grep -q '"success":true'; then
-  result 1 task-submit PASS "${TASK_S}s, taskId=$TASK_ID, success=true"
+# The mock provider's reply is not decomposition JSON, so the run is the Gameplay
+# fallback and GenericAgent performs no work. success true here was the silent
+# green receipt. The receipt is a task id, success false, the static no-work
+# summary, and a Failure audit disposition.
+if [ -n "$TASK_ID" ] \
+   && printf '%s' "$R" | grep -q '"success":false' \
+   && printf '%s' "$R" | grep -q 'No specialized agent performed work' \
+   && printf '%s' "$R" | grep -q '"disposition":"Failure"'; then
+  result 1 task-submit PASS "${TASK_S}s, taskId=$TASK_ID, success=false (no-work placeholder)"
 else
-  result 1 task-submit FAIL "${TASK_S}s, no taskId/success in: $(printf '%s' "$R" | head -c 300)"
+  result 1 task-submit FAIL "${TASK_S}s, expected taskId plus success false and the no-work summary, got: $(printf '%s' "$R" | head -c 300)"
 fi
 
 say "1.4 first-task audit is immediately visible (empty-first-audit bug fixed 2026-09-20)"
diff --git a/tests/uat/tier10.sh b/tests/uat/tier10.sh
index 5de7d1374..3f488c238 100644
--- a/tests/uat/tier10.sh
+++ b/tests/uat/tier10.sh
@@ -66,7 +66,16 @@ for i in $(seq 1 "$CONCURRENCY"); do
     body=$(curl -s --max-time 120 "$API/api/copilot/task" -H 'Content-Type: application/json' \
              -d "{\"task\": \"uat concurrent probe $i\", \"auditCount\": 1}")
     printf '%s\n' "$body" | grep -o '"taskId":"[^"]*"' | head -1 | cut -d'"' -f4 >>"$OUT/ids.txt"
-    printf '%s\n' "$body" | grep -oq '"success":true' && echo ok >>"$OUT/codes.txt" || echo bad >>"$OUT/codes.txt"
+    # success true is the silent placeholder receipt. A completed run reports the
+    # no-work placeholder. A shared-agent crash does not: it says the container
+    # cannot execute from state Executing, and it has no placeholder summary.
+    if printf '%s\n' "$body" | grep -q '"success":false' \
+       && printf '%s\n' "$body" | grep -q 'No specialized agent performed work' \
+       && ! printf '%s\n' "$body" | grep -q 'cannot execute from state Executing'; then
+      echo ok >>"$OUT/codes.txt"
+    else
+      echo bad >>"$OUT/codes.txt"
+    fi
   ) &
   SUBMIT_PIDS="$SUBMIT_PIDS $!"
 done
@@ -87,16 +96,20 @@ else
   result 10 concurrent-submissions-all-answered FAIL "only $SUBMITTED/$CONCURRENCY returned a taskId"
 fi
 
-say "10.1b every one of those orchestrations must succeed, not just be recorded"
+say "10.1b every one of those orchestrations must finish, not just be recorded"
 # This gates now. It did not always: concurrent runs registered different containers under the same
 # decomposition id (the parser's fallback emits "fallback-1" every time), so a run executed the other
 # run's container and failed with "cannot execute from state Executing", while ShutdownAllAsync tore
 # down both. Roughly half of every burst failed. LifecycleManager now scopes its agent map to the run
-# via BeginRunScope, and 8/8 succeed. A regression here means runs are sharing agents again.
-if [ "$OKS" -eq "$CONCURRENCY" ]; then
-  result 10 concurrent-orchestrations-succeed PASS "$OKS/$CONCURRENCY reported success"
+# via BeginRunScope. The mock fallback still performs no work, so each finished run is success false
+# with the no-work summary. That is not the shared-agent crash. A regression here is that crash, or
+# a body that is not the placeholder receipt.
+if grep -q 'cannot execute from state Executing' "$OUT/api-load.log"; then
+  result 10 concurrent-orchestrations-succeed FAIL "shared-agent regression: cannot execute from state Executing (api-load.log)"
+elif [ "$OKS" -eq "$CONCURRENCY" ]; then
+  result 10 concurrent-orchestrations-succeed PASS "$OKS/$CONCURRENCY finished as the no-work placeholder"
 else
-  result 10 concurrent-orchestrations-succeed FAIL "only $OKS/$CONCURRENCY reported success -- concurrent runs may be sharing agents again (look for 'cannot execute from state Executing' in api-load.log)"
+  result 10 concurrent-orchestrations-succeed FAIL "only $OKS/$CONCURRENCY were no-work placeholder receipts -- concurrent runs may be sharing agents again (look for 'cannot execute from state Executing' in api-load.log)"
 fi
 
 say "10.2 every id is distinct — no two concurrent tasks share an identity"