@@ -0,0 +1,9 @@
+---
+"@taskless/cli": patch
+---
+
+A rule delivered without any `.tests/` fixtures is now reported, and still written. A fixture-less rule works; what it cannot do is demonstrate that it does, since `taskless test` reports a pass over zero executed cases and that reads exactly like a rule proven to work. The warning names the rule and says so, and goes to stderr so it does not disturb `--json` on stdout.
+
+Reported rather than refused, deliberately. The holder of a fixture-less rule did not author it and cannot add fixtures the service will bless, so a refusal would leave them with no action available. Warning first means a gap in the seam surfaces from a report rather than from a blocked user, and the decision to harden it into a refusal can be made on evidence.
+
+The service now requires fixtures at construction, so a delivery without them should not occur — but `files` is a flat `{path, content}[]` in the published contract, with nothing that says one of them must be a fixture. The requirement is real and not visible across the seam, which is why this is checked against what actually arrived.
@@ -233,7 +233,11 @@ const createCommand = defineCommand({
             const rules = status.rules ?? [];
 
             for (const rule of rules) {
-              const ruleFile = await writeRuleFile(cwd, rule);
+              // To stderr, so a delivery worth remarking on is visible without
+              // corrupting `--json` on stdout. The rule is written either way.
+              const ruleFile = await writeRuleFile(cwd, rule, (message) => {
+                console.error(`Warning: ${message}`);
+              });
               writtenFiles.push(ruleFile);
 
               // A file set carries its fixtures as ordinary files under
@@ -499,7 +503,11 @@ const improveCommand = defineCommand({
             const rules = status.rules ?? [];
 
             for (const rule of rules) {
-              const ruleFile = await writeRuleFile(cwd, rule);
+              // To stderr, so a delivery worth remarking on is visible without
+              // corrupting `--json` on stdout. The rule is written either way.
+              const ruleFile = await writeRuleFile(cwd, rule, (message) => {
+                console.error(`Warning: ${message}`);
+              });
               writtenFiles.push(ruleFile);
 
               // A file set carries its fixtures as ordinary files under
 
@@ -165,6 +165,48 @@ export function describeIncompleteSet(
   return undefined;
 }
 
+/**
+ * Why a delivered file set carries no fixtures, or `undefined` when it does.
+ *
+ * **A WARNING, NOT A REFUSAL, AND THE ASYMMETRY IS THE POINT.** Everything
+ * {@link describeIncompleteSet} names is a rule that cannot work: no rule file,
+ * no config to scope it, no capture to invoke it. A rule with no fixtures works
+ * fine. What it cannot do is demonstrate that it does — `taskless test` reports
+ * a pass having executed nothing, which is indistinguishable from a rule that
+ * was proven. That is worth saying out loud and not worth refusing a delivery
+ * over, because refusing would leave the holder of a fixture-less rule with no
+ * action available to them: they did not author it and cannot add fixtures the
+ * service will bless.
+ *
+ * So this reports and writes. If the service ever delivers without fixtures we
+ * hear about it from a warning rather than from a blocked user, and the
+ * decision to harden it into a refusal can be made on evidence.
+ *
+ * **The contract cannot express this, which is why it is checked here.** The
+ * service requires fixtures at construction — a payload without them does not
+ * compile on their side — but `files` is a flat `{path, content}[]` in the
+ * OpenAPI document, with nothing that says one of them must be a fixture. The
+ * requirement is real and simply not visible across the seam, so the only way
+ * to know a delivery kept it is to look at what arrived.
+ *
+ * Asks only whether ANY file lands under `.tests/`. Depth is deliberately not
+ * policed: what makes a fixture meaningful differs per engine, every engine's
+ * own runner already judges it, and a second opinion here would be a worse one
+ * computed from less.
+ */
+export function describeMissingFixtures(
+  files: readonly DeliveredFile[]
+): string | undefined {
+  const prefix = `${RULE_TESTS_DIRECTORY}/`;
+  const hasFixture = files.some((file) => file.path.startsWith(prefix));
+  if (hasFixture) return undefined;
+  return (
+    `was delivered with no ${prefix} fixtures, so nothing exercises it: ` +
+    "`taskless test` reports a pass over zero cases, which is " +
+    "indistinguishable from a rule proven to work"
+  );
+}
+
 /** A delivered file set that may be written, or the reason it may not. */
 export type DeliveryAssessment =
   | { ok: true; files: readonly DeliveredFile[] }
 
@@ -17,17 +17,24 @@ import { isValidRuleId } from "./validate-id";
 import {
   assessDelivery,
   deliveredFiles,
+  describeMissingFixtures,
   writeDeliveredFileSet,
 } from "./deliver";
 
 /**
  * Write a generated rule's content into its own rule directory —
  * `.taskless/rules/sg/{kebab-id}/{kebab-id}.yml` for the engine-less payloads
  * the API delivers today (see {@link resolveIngestEngine}).
+ *
+ * `onWarning` receives anything worth saying about a delivery that was still
+ * written. Optional, and a caller that omits it loses the message rather than
+ * the write — see {@link describeMissingFixtures} for why a missing fixture is
+ * reported this way instead of refused.
  */
 export async function writeRuleFile(
   cwd: string,
-  rule: GeneratedRule
+  rule: GeneratedRule,
+  onWarning?: (message: string) => void
 ): Promise<string> {
   if (!isValidRuleId(rule.id)) {
     throw new Error(`Invalid rule ID "${rule.id}"`);
@@ -68,6 +75,12 @@ export async function writeRuleFile(
     // repair is not special-cased. The single-content path below has no set to
     // be authoritative about and keeps overwriting one file.
     await writeDeliveredFileSet(cwd, engine, rule.id, assessment);
+    // AFTER the write, deliberately. This is an observation about a rule that
+    // is now on disk, and warning first would read as a reason it was refused.
+    const missingFixtures = describeMissingFixtures(assessment.files);
+    if (missingFixtures !== undefined) {
+      onWarning?.(`Rule "${rule.id}" ${missingFixtures}.`);
+    }
     // The rule file, so the caller's contract ("where did this rule land")
     // is unchanged whichever envelope delivered it.
     return ruleFilePath(cwd, engine, rule.id);
 
@@ -268,7 +268,9 @@ async function repairWithheldRules(
     }
 
     try {
-      await writeRuleFile(cwd, rule);
+      // A restored rule missing its fixtures is still the blessed bytes and is
+      // still worth writing; the notice rides along with the repair's own.
+      await writeRuleFile(cwd, rule, (message) => notices.push(message));
     } catch (error) {
       // A failed WRITE and a failed CLEANUP ask the reader for opposite
       // things, and saying "could not be written" for both is worse than
 
@@ -16,7 +16,10 @@ import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { writeRuleFile } from "../src/rules/files";
-import { PurgeIncompleteError } from "../src/rules/deliver";
+import {
+  PurgeIncompleteError,
+  describeMissingFixtures,
+} from "../src/rules/deliver";
 import { ruleDirectory } from "../src/rules/engines";
 import type { GeneratedRule } from "../src/api/rules";
 
@@ -603,3 +606,100 @@ asUser("a purge that cannot finish", () => {
     }
   });
 });
+
+describe("a delivery that carries no fixtures", () => {
+  const SG_RULE = "id: no-eval-abc12345\n";
+
+  it("warns, and still writes the rule", async () => {
+    const warnings: string[] = [];
+    await writeRuleFile(
+      cwd,
+      delivered("sg", "no-eval-abc12345", [
+        { path: "no-eval-abc12345.yml", content: SG_RULE },
+      ]),
+      (message) => warnings.push(message)
+    );
+
+    // Both halves matter. Warning without writing would be a refusal wearing a
+    // warning's clothes, and writing without warning is the silence this
+    // exists to break.
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain("no-eval-abc12345");
+    expect(warnings[0]).toContain(".tests/");
+    expect(
+      existsSync(
+        join(
+          ruleDirectory(cwd, "sg", "no-eval-abc12345"),
+          "no-eval-abc12345.yml"
+        )
+      )
+    ).toBe(true);
+  });
+
+  it("says why it matters rather than only what is absent", async () => {
+    const warnings: string[] = [];
+    await writeRuleFile(
+      cwd,
+      delivered("sg", "no-eval-abc12345", [
+        { path: "no-eval-abc12345.yml", content: SG_RULE },
+      ]),
+      (message) => warnings.push(message)
+    );
+
+    // The consequence is the reason this is worth printing: a fixture-less
+    // rule passes `test` over zero cases and reads as proven.
+    expect(warnings[0]).toContain("nothing exercises it");
+  });
+
+  it("stays silent when fixtures are present", async () => {
+    const warnings: string[] = [];
+    await writeRuleFile(
+      cwd,
+      delivered("sg", "no-eval-abc12345", [
+        { path: "no-eval-abc12345.yml", content: SG_RULE },
+        { path: ".tests/valid/sample.ts", content: "const x = 1;\n" },
+      ]),
+      (message) => warnings.push(message)
+    );
+
+    expect(warnings).toEqual([]);
+  });
+
+  it("loses the message, not the write, when no handler is passed", async () => {
+    // `onWarning` is optional, and a caller that omits it must still get the
+    // rule on disk rather than an unhandled throw.
+    await expect(
+      writeRuleFile(
+        cwd,
+        delivered("sg", "no-eval-abc12345", [
+          { path: "no-eval-abc12345.yml", content: SG_RULE },
+        ])
+      )
+    ).resolves.toBeTypeOf("string");
+  });
+});
+
+describe("what counts as a fixture", () => {
+  it("accepts a fixture at any depth under .tests/", () => {
+    // Depth is deliberately not policed here; each engine's runner judges what
+    // a meaningful fixture is.
+    expect(
+      describeMissingFixtures([
+        { path: "check.ts", content: "" },
+        { path: ".tests/fail/deeply/nested/case/input.ts", content: "" },
+      ])
+    ).toBeUndefined();
+  });
+
+  it("does not accept a nested .tests/ that an engine would read", () => {
+    // Only the top-level `.tests/` is the fixture directory. `captures/.tests/`
+    // is a file an engine reads, which is the same distinction
+    // `PRESERVED_SUBTREES` draws when it decides what a purge may remove.
+    expect(
+      describeMissingFixtures([
+        { path: "check.ts", content: "" },
+        { path: "captures/.tests/logs.yml", content: "" },
+      ])
+    ).toBeDefined();
+  });
+});