chore(cli): make the reference standalone, not a demo artifact

Follows the subpath rename through the code. The `sg` and `vale` entries
are reference material too -- they are simply not what the demo command
writes -- so scoping the corpus to "demo" was wrong in the same way the
published name was.

Moves, by what each file is actually about rather than by where it started:

  src/rules/demo/reference.ts   -> src/rules/reference.ts
  src/rules/demo/constraints.ts -> src/rules/constraints.ts

The constraints move furthest and had the least business being there:
they describe what `verify` and `test` enforce on ANY rule. Nothing about
them is demonstration-specific, and filing them under `demo/` implied a
scope they never had.

`src/rules/demo/` keeps `manifest.ts` and `rule.ts`, which really are the
rules the demo command writes.

Identifiers follow: buildDemoReference -> buildReference, DemoReference ->
Reference, DEMO_REFERENCE_* -> REFERENCE_*. Script and task follow too:
`write-demo-reference.ts` -> `write-reference.ts`, and `demo:reference` ->
`reference`. Tests renamed to match the modules they cover.

`demo:manifests` and `print-demo-manifests.ts` keep the prefix, and that is
the line: they exist so CI can stage what the demo command writes, which is
genuinely about the demo.

No behaviour change. The payload is byte-identical -- regenerated after the
move and it matched -- and the asset guard was re-broken to confirm it
still refuses a mis-declared export under the new path.

Author: theCodeDrift

packages/cli/package.json

@@ -20,8 +20,8 @@
     "prebuild": "tsx scripts/fetch-rule-hash-vectors.ts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "demo:reference": "tsx scripts/write-demo-reference.ts",
-    "demo:manifests": "tsx scripts/print-demo-manifests.ts"
+    "demo:manifests": "tsx scripts/print-demo-manifests.ts",
+    "reference": "tsx scripts/write-reference.ts"
   },
   "type": "module",
   "module": "./dist/index.js",

…ages/cli/scripts/write-demo-reference.ts packages/cli/scripts/write-reference.tspackages/cli/scripts/write-demo-reference.ts renamed to packages/cli/scripts/write-reference.ts packages/cli/scripts/write-demo-reference.ts renamed to packages/cli/scripts/write-reference.ts

@@ -7,15 +7,15 @@
  *
  * Reads the asset files directly rather than importing `rule.ts`, whose `?raw`
  * specifiers only resolve under a vite transform. Both read `DEMO_MANIFESTS`,
- * and `test/demo-reference.test.ts` asserts they agree.
+ * and `test/reference.test.ts` asserts they agree.
  *
- * Run: pnpm --filter @taskless/cli demo:reference
+ * Run: pnpm --filter @taskless/cli reference
  */
 
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-import { buildDemoReference } from "../src/rules/demo/reference";
+import { buildReference } from "../src/rules/reference";
 import { DEMO_MANIFESTS } from "../src/rules/demo/manifest";
 
 const packageRoot = join(import.meta.dirname, "..");
@@ -48,7 +48,7 @@ const rules = await Promise.all(
 const target = join(packageRoot, "assets", "reference.json");
 await writeFile(
   target,
-  `${JSON.stringify(buildDemoReference(rules), undefined, 2)}\n`,
+  `${JSON.stringify(buildReference(rules), undefined, 2)}\n`,
   "utf8"
 );
 console.log(`Wrote ${target}`);

…ckages/cli/src/rules/demo/constraints.ts packages/cli/src/rules/constraints.tspackages/cli/src/rules/demo/constraints.ts renamed to packages/cli/src/rules/constraints.ts packages/cli/src/rules/demo/constraints.ts renamed to packages/cli/src/rules/constraints.ts

@@ -1,4 +1,4 @@
-import type { EngineName } from "../layout";
+import type { EngineName } from "./layout";
 
 /**
  * What `verify` enforces beyond the engine's own schema.
@@ -19,7 +19,7 @@ import type { EngineName } from "../layout";
  * "`verify` never reads `language`", which stopped being true when
  * `validateLanguage` landed. Nothing failed, because prose has no test.
  *
- * `test/rule-constraints.test.ts` builds a rule that violates each entry and
+ * `test/constraints.test.ts` builds a rule that violates each entry and
  * asserts `verify` rejects it, keyed on `id`. An entry describing a check that
  * no longer fires fails the suite; a check with no entry is invisible to that
  * test and is the gap this list is trying to close, so add one when you add a

packages/cli/src/rules/demo/manifest.ts

@@ -8,7 +8,7 @@
  *
  * The paths therefore live here, stated once. `rule.ts` embeds exactly these
  * lists, the generator reads exactly these lists off disk, and
- * `test/demo-reference.test.ts` asserts the two agree — so the rules the CLI
+ * `test/reference.test.ts` asserts the two agree — so the rules the CLI
  * writes and the payload handed to other teams cannot come to describe
  * different things.
  *

packages/cli/src/rules/demo/reference.ts packages/cli/src/rules/reference.tspackages/cli/src/rules/demo/reference.ts renamed to packages/cli/src/rules/reference.ts

@@ -1,5 +1,5 @@
-import type { DeliveredFile } from "../deliver";
-import type { EngineName } from "../layout";
+import type { DeliveredFile } from "./deliver";
+import type { EngineName } from "./layout";
 import { RULE_CONSTRAINTS, type RuleConstraint } from "./constraints";
 
 /**
@@ -21,10 +21,10 @@ import { RULE_CONSTRAINTS, type RuleConstraint } from "./constraints";
  * and both tiers are inert, so a signature on them would imply a gate that does
  * not exist.
  */
-export const DEMO_REFERENCE_SIGNATURE = `1;h=sha-256;d=${"0".repeat(64)}`;
+export const REFERENCE_SIGNATURE = `1;h=sha-256;d=${"0".repeat(64)}`;
 
 /** Bumped when a consumer would have to change code to keep reading this. */
-export const DEMO_REFERENCE_VERSION = 1;
+export const REFERENCE_VERSION = 1;
 
 /**
  * The check this corpus exists to make possible, stated in the artifact itself.
@@ -44,7 +44,7 @@ export const DEMO_REFERENCE_VERSION = 1;
  * disagreement about our validator. Any consumer would have hit it on their
  * first run.
  */
-export const DEMO_REFERENCE_PROTOCOL = [
+export const REFERENCE_PROTOCOL = [
   "Generate a rule from `prompt`, using your own pipeline.",
   "Run `taskless verify` over what you generated. It enforces constraints beyond the engine's own schema, listed in `constraints` below, so a rule the engine executes correctly can still be refused. A rule that fails here is not deliverable however well it behaves, and every later step would be measuring the wrong thing. Check `enforcedBy` before concluding anything: some constraints are only decided once the fixtures run.",
   "Run your generated rule against your own cases. It should pass; if it does not, the disagreement is inside your pipeline and nothing below will be informative.",
@@ -53,7 +53,7 @@ export const DEMO_REFERENCE_PROTOCOL = [
 ];
 
 /** One rule as this corpus carries it. */
-export interface DemoReferenceRule {
+export interface ReferenceRule {
   engine: EngineName;
   id: string;
   /** The generation request, as a caller would phrase it. */
@@ -66,7 +66,7 @@ export interface DemoReferenceRule {
   signature?: string;
 }
 
-export interface DemoReference {
+export interface Reference {
   version: number;
   protocol: string[];
   /**
@@ -78,11 +78,11 @@ export interface DemoReference {
    * enforces it, which decides the order an eval has to run in.
    */
   constraints: RuleConstraint[];
-  rules: DemoReferenceRule[];
+  rules: ReferenceRule[];
 }
 
-/** The input shape `buildDemoReference` reads, satisfied by both callers. */
-export interface DemoReferenceInput {
+/** The input shape `buildReference` reads, satisfied by both callers. */
+export interface ReferenceInput {
   engine: EngineName;
   ruleId: string;
   prompt: string;
@@ -106,22 +106,18 @@ const plain = (files: readonly DeliveredFile[]) =>
  * Built from the rules rather than restating them, so the corpus and what the
  * CLI writes cannot describe different things.
  */
-export function buildDemoReference(
-  rules: readonly DemoReferenceInput[]
-): DemoReference {
+export function buildReference(rules: readonly ReferenceInput[]): Reference {
   return {
-    version: DEMO_REFERENCE_VERSION,
-    protocol: DEMO_REFERENCE_PROTOCOL,
+    version: REFERENCE_VERSION,
+    protocol: REFERENCE_PROTOCOL,
     constraints: [...RULE_CONSTRAINTS],
     rules: rules.map((rule) => ({
       engine: rule.engine,
       id: rule.ruleId,
       prompt: rule.prompt,
       rule: plain(rule.ruleFiles),
       tests: plain(rule.testFiles),
-      ...(rule.engine === "runtime"
-        ? { signature: DEMO_REFERENCE_SIGNATURE }
-        : {}),
+      ...(rule.engine === "runtime" ? { signature: REFERENCE_SIGNATURE } : {}),
     })),
   };
 }

…ckages/cli/test/rule-constraints.test.ts packages/cli/test/constraints.test.tspackages/cli/test/rule-constraints.test.ts renamed to packages/cli/test/constraints.test.ts packages/cli/test/rule-constraints.test.ts renamed to packages/cli/test/constraints.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { stringify } from "yaml";
 
-import { RULE_CONSTRAINTS } from "../src/rules/demo/constraints";
+import { RULE_CONSTRAINTS } from "../src/rules/constraints";
 import { testOneRule, verifyOneRule } from "../src/rules/inspect";
 
 /**

packages/cli/test/demo-reference.test.ts packages/cli/test/reference.test.tspackages/cli/test/demo-reference.test.ts renamed to packages/cli/test/reference.test.ts

@@ -4,11 +4,8 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 
 import { parseSignature } from "../src/rules/rule-hash";
-import {
-  buildDemoReference,
-  type DemoReference,
-} from "../src/rules/demo/reference";
-import { RULE_CONSTRAINTS } from "../src/rules/demo/constraints";
+import { buildReference, type Reference } from "../src/rules/reference";
+import { RULE_CONSTRAINTS } from "../src/rules/constraints";
 import { DEMO_MANIFESTS, writtenPaths } from "../src/rules/demo/manifest";
 import { DEMO_RULES } from "../src/rules/demo/rule";
 
@@ -28,19 +25,19 @@ const referencePath = join(
   "reference.json"
 );
 
-async function readReference(): Promise<DemoReference> {
-  return JSON.parse(await readFile(referencePath, "utf8")) as DemoReference;
+async function readReference(): Promise<Reference> {
+  return JSON.parse(await readFile(referencePath, "utf8")) as Reference;
 }
 
-function ruleFor(reference: DemoReference, engine: string) {
+function ruleFor(reference: Reference, engine: string) {
   const rule = reference.rules.find((entry) => entry.engine === engine);
   if (rule === undefined) throw new Error(`reference has no ${engine} rule`);
   return rule;
 }
 
 describe("the demo reference payload", () => {
-  it("is current — regenerate with `pnpm --filter @taskless/cli demo:reference`", async () => {
-    expect(await readReference()).toEqual(buildDemoReference(DEMO_RULES));
+  it("is current — regenerate with `pnpm --filter @taskless/cli reference`", async () => {
+    expect(await readReference()).toEqual(buildReference(DEMO_RULES));
   });
 
   it("embeds exactly the files each manifest lists", () => {