@@ -1,11 +1,14 @@
 import { spawnSync } from "node:child_process";
 import {
   existsSync,
+  mkdirSync,
+  mkdtempSync,
   readdirSync,
   readFileSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
+import { tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import { describe, expect, test } from "bun:test";
 
@@ -240,7 +243,10 @@ describe("live knip scan semantics", () => {
 
   test("production agent scan removes test-file consumers from the surface", () => {
     const rules = loadAllowlist();
-    const spawn = knipAgentProductionSpawn(knipBin, agentWorkspaceIds(rules));
+    const spawn = knipAgentProductionSpawn(
+      knipBin,
+      agentWorkspaceIds(join(repoRoot, "agents")),
+    );
     const ran = spawnSync(spawn.command, spawn.args, {
       cwd: repoRoot,
       encoding: "utf8",
@@ -449,19 +455,24 @@ describe("pinned scan invocation", () => {
     expect(() => knipAgentProductionSpawn("/repo/x", [])).toThrow();
   });
 
-  test("agent workspace ids derive from the allowlist and fail closed", () => {
-    const rules = parseAllowlistText(
-      "agents/coder/src/index.ts: agent\n" +
-        "agents/coder/src/index.ts: agent\n" +
-        "agents/dispatch/src/index.ts: agent\n" +
-        "src/auth/codex/constants.ts: CODEX_BASE_URL\n",
-    );
-    // Parse dedupes nothing at rule level; the derivation dedupes ids.
-    expect(agentWorkspaceIds(rules)).toEqual([
-      "agents/coder",
-      "agents/dispatch",
-    ]);
-    expect(() => agentWorkspaceIds(parseAllowlistText("vendor/\n"))).toThrow();
+  test("agent workspace ids are the agents directory and fail closed", () => {
+    const agentsRoot = join(repoRoot, "agents");
+    const fromDisk = readdirSync(agentsRoot, { withFileTypes: true })
+      .filter(
+        (entry) =>
+          entry.isDirectory() &&
+          existsSync(join(agentsRoot, entry.name, "package.json")),
+      )
+      .map((entry) => `agents/${entry.name}`)
+      .sort();
+    expect(fromDisk.length).toBeGreaterThan(0);
+    expect(agentWorkspaceIds(agentsRoot)).toEqual(fromDisk);
+    const empty = mkdtempSync(join(tmpdir(), "dead-export-agents-"));
+    try {
+      expect(() => agentWorkspaceIds(empty)).toThrow();
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
   });
 
   test("parseGuardConfig rejects a missing tsconfig or floor and extra keys", () => {
@@ -543,6 +554,65 @@ describe("violation end to end", () => {
       rmSync(probePath, { force: true });
     }
   }, 240_000);
+
+  test("a test-only export in an extra agent workspace fails the guard", () => {
+    const id = `dead-export-guard-agent-${process.pid}`;
+    const exportName = `deadExportGuardAgentProbe${process.pid}`;
+    const dir = join(repoRoot, "agents", id);
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: `@corbits/code-agent-${id}`,
+        private: true,
+        type: "module",
+      }),
+    );
+    writeFileSync(
+      join(dir, "src", "index.ts"),
+      `export const ${exportName} = 1;\n`,
+    );
+    writeFileSync(
+      join(dir, "src", "index.test.ts"),
+      `import { ${exportName} } from "./index.js";\nvoid ${exportName};\n`,
+    );
+    try {
+      const knipBin = join(repoRoot, "node_modules", ".bin", "knip");
+      const defaultSpawn = knipDefaultSpawn(knipBin);
+      const defaultRun = spawnSync(defaultSpawn.command, defaultSpawn.args, {
+        cwd: repoRoot,
+        encoding: "utf8",
+      });
+      expect(defaultRun.status).toBe(0);
+      const defaultFindings = parseKnipReport(String(defaultRun.stdout));
+      expect(
+        defaultFindings.some(
+          (finding) =>
+            finding.file === `agents/${id}/src/index.ts` &&
+            finding.name === exportName,
+        ),
+      ).toBe(false);
+
+      const ran = spawnSync(
+        process.execPath,
+        ["scripts/check-dead-exports.ts"],
+        {
+          cwd: repoRoot,
+          encoding: "utf8",
+          env: {
+            ...process.env,
+            DEAD_EXPORT_GUARD_SCANNED_FILES: String(liveScannedFileCount()),
+          },
+        },
+      );
+      expect(ran.status).toBe(1);
+      expect(`${ran.stdout}\n${ran.stderr}`).toContain(
+        `agents/${id}/src/index.ts: ${exportName}`,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }, 240_000);
 });
 
 // A re-created barrel would silently resurrect a surface the purge removed.
 
@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -382,22 +382,30 @@ export function knipAgentProductionSpawn(
   ]);
 }
 
-// The agent workspaces the production scan must cover, derived from the
-// allowlist's `agents/<id>/src/index.ts` entries so the scan stays pinned to
-// the surface the allowlist governs. Fails closed when the surface names no
+// Every agents/ workspace, not the allowlist. A package whose entry exports
+// are imported only by its own test is invisible to the default scan (knip
+// counts test files there) and would skip this production scan if membership
+// came from allowlist entries. Fails closed when the directory names no
 // workspace: a silent no-op scan cannot be trusted.
-export function agentWorkspaceIds(rules: readonly AllowRule[]): string[] {
-  const ids = new Set<string>();
-  for (const rule of rules) {
-    if (rule.kind === "exact" && rule.file.startsWith("agents/")) {
-      const id = rule.file.slice("agents/".length).split("/")[0];
-      if (id !== undefined && id !== "") ids.add(`agents/${id}`);
-    }
+export function agentWorkspaceIds(agentsRoot: string): string[] {
+  let names: string[];
+  try {
+    names = readdirSync(agentsRoot, { withFileTypes: true }).flatMap((entry) =>
+      entry.isDirectory() &&
+      !entry.name.startsWith(".") &&
+      existsSync(join(agentsRoot, entry.name, "package.json"))
+        ? [entry.name]
+        : [],
+    );
+  } catch (err) {
+    throw new Error(
+      `agent workspace root not readable (${agentsRoot}): ${(err as Error).message}`,
+    );
   }
-  const sorted = [...ids].sort();
+  const sorted = names.map((name) => `agents/${name}`).sort();
   if (sorted.length === 0) {
     throw new Error(
-      "dead-export allowlist names no agents/<id>/src/index.ts surface: " +
+      `agents directory names no workspace (${agentsRoot}): ` +
         "the agent-workspace production scan has nothing to cover",
     );
   }
@@ -494,7 +502,7 @@ function fail(message: string): never {
 //
 // Both run under the pinned spawn contract; a failing or malformed
 // report fails the gate rather than narrowing it silently.
-export function runKnipScans(rules: readonly AllowRule[]): DeadExport[] {
+export function runKnipScans(): DeadExport[] {
   requireKnipConfigs();
   const merge = (reports: readonly DeadExport[]): DeadExport[] => {
     const seen = new Set<string>();
@@ -534,7 +542,7 @@ export function runKnipScans(rules: readonly AllowRule[]): DeadExport[] {
     knipDefaultSpawn(knipBin),
     "knip default scan",
   );
-  const agentWorkspaces = agentWorkspaceIds(rules);
+  const agentWorkspaces = agentWorkspaceIds(join(repoRoot, "agents"));
   const agentFindings = spawnAndParse(
     knipAgentProductionSpawn(knipBin, agentWorkspaces),
     "knip production agent scan",
@@ -561,7 +569,7 @@ function main(): void {
     );
   }
   const rules = parseAllowlistText(allowlistText);
-  const findings = runKnipScans(rules);
+  const findings = runKnipScans();
   const outcome = evaluateGuard(rules, findings);
   let scannedFiles: number;
   const injectedCount = parseInjectedScannedFiles(process.env[scannedFilesEnv]);