@agentsfleet/orly 0.10.0 → 0.10.2

package/audits/design-tokens.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
-# design-tokens.sh — enforce design-system token discipline across
-# ui/packages/{app,website}/**/*.tsx.
+# design-tokens.sh — enforce design-system token discipline and flat fills
+# across the app, website, and shared design system.
 #
 # Dispatch façade: dispatch/write_ts_adhere_bun.md (Design Tokens / DESIGN TOKEN GATE)
 # Fires in: CONFORM (via `make harness-verify` in `agentsfleet`).
@@ -62,6 +62,23 @@ PATTERNS=(
   '(text|bg|border)-(red|blue|green|yellow|purple|indigo|violet|pink|orange|gray|slate|zinc|neutral)-[0-9]:::use semantic tokens (text-destructive, text-error, text-success, …)'
 )
 
+readonly GRADIENT_REGEX='(repeating-)?(linear|radial|conic)-gradient[[:space:]]*\('
+
+# Consumers may select a font role, but only the design system defines it.
+check_font_ownership() {
+  local f="$1"
+  case "$f" in ui/packages/design-system/*) return ;; esac
+  awk '
+    {
+      source = $0
+      gsub(/font-family[[:space:]]*:[[:space:]]*var\(--ff-(sans|mono|display)\)/, "")
+      invalid = /font-family[[:space:]]*:|fontFamily[[:space:]]*:[[:space:]]*["\047]|--(ff|font)-(sans|mono|display)[[:space:]]*:|font-\[/
+      if (FILENAME ~ /^ui\/packages\/app\// && /font-display|DisplayXL|DisplayLG/) invalid = 1
+      if (invalid) printf "%s:%d:%s\n", FILENAME, FNR, source
+    }
+  ' "$f"
+}
+
 # ── File scope ───────────────────────────────────────────────────────────
 in_scope() {
   local f="$1"
@@ -70,8 +87,17 @@ in_scope() {
     *tests/e2e/*) return 1 ;;
     ui/packages/app/*.tsx|ui/packages/app/*.jsx) return 0 ;;
     ui/packages/website/*.tsx|ui/packages/website/*.jsx) return 0 ;;
-    ui/packages/app/**/*.tsx|ui/packages/app/**/*.jsx) return 0 ;;
-    ui/packages/website/**/*.tsx|ui/packages/website/**/*.jsx) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+in_gradient_scope() {
+  local f="$1"
+  case "$f" in
+    *.test.*|*.spec.*|*/tests/*|*/coverage/*|*/dist/*|*/.next/*|*/node_modules/*) return 1 ;;
+    ui/packages/app/*.css|ui/packages/app/*.js|ui/packages/app/*.jsx|ui/packages/app/*.mjs|ui/packages/app/*.ts|ui/packages/app/*.tsx) return 0 ;;
+    ui/packages/website/*.css|ui/packages/website/*.js|ui/packages/website/*.jsx|ui/packages/website/*.mjs|ui/packages/website/*.ts|ui/packages/website/*.tsx) return 0 ;;
+    ui/packages/design-system/*.css|ui/packages/design-system/*.js|ui/packages/design-system/*.jsx|ui/packages/design-system/*.mjs|ui/packages/design-system/*.ts|ui/packages/design-system/*.tsx) return 0 ;;
     *) return 1 ;;
   esac
 }
@@ -79,12 +105,14 @@ in_scope() {
 case "$MODE" in
   --staged|staged)
     FILES=$(git diff --cached --name-only --diff-filter=ACMRT 2>/dev/null || true)
+    GRADIENT_CANDIDATES="$FILES"
     ;;
   --all|all)
     # `git ls-files` reports the index, which includes staged content —
     # so pre-commit-style invocations see staged-but-not-committed files
     # without needing a `--staged` flag.
     FILES=$(git ls-files -- 'ui/packages/app/*.tsx' 'ui/packages/app/*.jsx' 'ui/packages/website/*.tsx' 'ui/packages/website/*.jsx' 2>/dev/null || true)
+    GRADIENT_CANDIDATES=$(git ls-files -- ui/packages/app ui/packages/website ui/packages/design-system 2>/dev/null || true)
     ;;
   *)
     echo "usage: $0 [--all|--staged]" >&2
@@ -127,10 +155,34 @@ if [ "${#SCOPED_FILES[@]}" -gt 0 ]; then
   done
 fi
 
+GRADIENT_FILES=()
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  [ ! -f "$f" ] && continue
+  in_gradient_scope "$f" || continue
+  GRADIENT_FILES+=("$f")
+  while IFS= read -r match; do
+    [ -z "$match" ] && continue
+    printf '%s\n  -> define fonts in design-system tokens.css; use sans for app UI and mono for technical values\n' "$match"
+    SEEN_FILES_LIST="${SEEN_FILES_LIST}${f}"$'\n'
+    FAIL=1
+  done < <(check_font_ownership "$f")
+done <<< "$GRADIENT_CANDIDATES"
+
+if [ "${#GRADIENT_FILES[@]}" -gt 0 ]; then
+  while IFS= read -r match; do
+    [ -z "$match" ] && continue
+    f="${match%%:*}"
+    printf '%s\n  -> use a solid design-system color token; gradients are forbidden\n' "$match"
+    SEEN_FILES_LIST="${SEEN_FILES_LIST}${f}"$'\n'
+    FAIL=1
+  done < <(grep -nHE "$GRADIENT_REGEX" "${GRADIENT_FILES[@]}" 2>/dev/null || true)
+fi
+
 FILES_WITH_VIOLATIONS=$(printf '%s' "$SEEN_FILES_LIST" | sort -u | grep -c . || true)
 
 if [ "$FAIL" = "0" ]; then
-  echo "OK: design-token discipline — no arbitraries that have a token equivalent (mode=$MODE)"
+  echo "OK: design-token discipline — named utilities and flat fills verified (mode=$MODE)"
   exit 0
 fi
 

package/dispatch/write_changelog.md

@@ -40,8 +40,10 @@ a gate skip.
   names, money amounts stay verbatim.
 - **Internal cleanup** gets aggressive trimming, not a paragraph.
 - **History is archived, not rewritten** — past entries are an immutable record.
-- **Rate constants** stay pinned across the three files (`tenant_billing.zig`,
-  `rates.ts`, `rates.mdx`) — a changelog money/rate claim must match all three.
+- **Rate constants** are pinned by `cross_runtime_rates.rs`, which reads the
+  app and Command-Line Interface (CLI) mirrors against the Rust constant. A
+  changelog money or rate claim must match those, and `rates.mdx` in the docs
+  repository, which no test can reach.
 
 ## Required output (self-audit line before committing the changelog)
 

package/docs/CHANGELOG_VOICE.md

@@ -14,5 +14,5 @@ Editing `~/Projects/docs/changelog.mdx` or any other Mintlify `<Update>` block.
 - **Internal cleanup / refactor entries get the most aggressive trimming.** One lead paragraph + one bullet list. Skip "Test coverage" sections unless the test count is the headline. Indy's exact direction: *"Keep internal code cleanup, refactor to a minimal."*
 - **Never drop load-bearing facts.** Error codes (`UZ-AUTH-003`), endpoint paths + method + body shape + status code, env var names + defaults, schema column / table names, CLI subcommand + flag names, migration steps, money amounts. Tighten prose, not meaning.
 - **Historical entries are archives.** Brevity-pass them; never rewrite the past. A typo correction (e.g. `$0.001` → `$0.01` when it was never true) is allowed and must be called out in the commit message.
-- **Rate constants flow through three pinned files only:** `rustd/crates/afd_billing/src/nanos.rs`, `ui/packages/website/src/lib/rates.ts`, `~/Projects/docs/snippets/rates.mdx`. Bumping a rate requires a paired Pull Request (PR) across the docs repo — there is no automated guard. In `*.mdx`, use `import { STARTER_CREDIT, EVENT_RATE, STAGE_RATE } from "/snippets/rates.mdx"` instead of hand-typing `$5`.
+- **Rate constants stay pinned across the runtime surfaces, and a test says so.** `rustd/crates/afd_billing/tests/cross_runtime_rates.rs` reads `ui/packages/app/lib/types.ts` and `cli/src/constants/billing.ts` and fails when either drifts from `rustd/crates/afd_billing/src/nanos.rs` — a test beside the constant it defends, not a gate nothing invokes. Public docs are the one surface it cannot reach: when a rate changes, update `~/Projects/docs/snippets/rates.mdx` in a paired Pull Request (PR). In `*.mdx`, import its named values rather than hand-typing money amounts.
 - **The Mintlify reference Indy pasted (May 1 / May 8 entries) is canonical voice.** Mirror its rhythm, not its product nouns.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsfleet/orly",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Repository-scoped engineering harness: renders agent rules, materialises the gates that enforce them, and proves the PR boundary \u2014 for any coding agent.",
   "license": "MIT",
   "type": "module",

package/src/config.test.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 
-import { CONFIG_PATH, managedDrift, readConfig, readConfigSync, seedConfig, selectPacks, staleVersion, writeConfig } from "./config";
+import { CONFIG_PATH, contentDigest, managedDrift, readConfig, readConfigSync, seedConfig, selectPacks, staleVersion, writeConfig } from "./config";
 import { RulesModel } from "./model";
 
 const ROOT = resolve(import.meta.dir, "..");
@@ -156,6 +156,40 @@ describe("staleVersion", () => {
   });
 });
 
+describe("managedDrift — content", () => {
+  test("a managed file edited after orly wrote it is drift", async () => {
+    // The gap this closes was not hypothetical: a consuming repository added a
+    // gradient ban and a font-ownership check straight to a materialised gate
+    // script, the pack never learned them, and the next update deleted them —
+    // with doctor green the whole way, because it asked only whether the file
+    // EXISTED. A gate whose checks can be removed under a passing verifier is
+    // not a gate.
+    const root = scratch();
+    const wrote = "check_one\ncheck_two\n";
+    writeFileSync(join(root, "audit.sh"), wrote);
+    const config = { ...(await seedConfig(root)), managed: ["audit.sh"], digests: { "audit.sh": contentDigest(new TextEncoder().encode(wrote)) } };
+    expect(managedDrift(root, config)).toEqual([]);
+
+    writeFileSync(join(root, "audit.sh"), "check_one\n");
+    const drift = managedDrift(root, config);
+    expect(drift).toHaveLength(1);
+    expect(drift[0]).toContain("audit.sh");
+    expect(drift[0]).toContain("edited after orly wrote it");
+    // Deliberately NOT "run orly update": the local content may be the better
+    // version, and update discards it. The source is where it has to go.
+    expect(drift[0]).toContain("move the change into the pack source");
+  });
+
+  test("a file with no recorded digest makes no claim", async () => {
+    // Two cases share this path: a config written before digests existed, and a
+    // hook orly manages but did not author. Neither may be reported as drift.
+    const root = scratch();
+    writeFileSync(join(root, "hook.sh"), "the repository's own\n");
+    const config = { ...(await seedConfig(root)), managed: ["hook.sh"], digests: {} };
+    expect(managedDrift(root, config)).toEqual([]);
+  });
+});
+
 describe("managedDrift", () => {
   test("every managed file present reports no drift", async () => {
     const root = scratch();
@@ -223,6 +257,7 @@ describe("writeConfig", () => {
       commands: { conform: [["make", "audit"]] },
       surfaces: { user: ["src/"], docs: ["docs/"] },
       managed: ["AGENTS.md"],
+      digests: {},
     };
     await writeConfig(root, mine);
     await writeConfig(root, { ...(await readConfig(root))!, orly_version: "0.4.0", managed: ["AGENTS.md", "dispatch/write_rust.md"] });

package/src/config.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, extname, join, relative } from "node:path";
 
@@ -16,6 +17,9 @@ const EXTENSIONS_FIELD = "extensions";
 const PACKS_FIELD = "packs";
 const VERSION_FIELD = "orly_version";
 const MANAGED_FIELD = "managed";
+const DIGESTS_FIELD = "digests";
+const DIGEST_ALGORITHM = "sha256";
+const DIGEST_ENCODING = "hex";
 const COMMANDS_FIELD = "commands";
 const CONFORM_COMMAND = "conform";
 const MAKE_COMMAND = "make";
@@ -65,6 +69,7 @@ export type RepoConfig = {
   commands: Record<string, string[][]>;
   surfaces: JsonObject | undefined;
   managed: string[];
+  digests: Record<string, string>;
 };
 
 export function configPath(targetRoot: string): string {
@@ -109,9 +114,26 @@ function parseConfig(value: JsonObject): RepoConfig {
     commands: readCommands(value[COMMANDS_FIELD]),
     surfaces: isObject(value.surfaces) ? value.surfaces : undefined,
     managed: stringArray(value[MANAGED_FIELD] ?? [], `${CONFIG_PATH} ${MANAGED_FIELD}`),
+    digests: readDigests(value[DIGESTS_FIELD]),
   };
 }
 
+// Absent in a config written before digests existed, and absent per-file for
+// anything orly did not author (a hook it declined to overwrite). Both cases
+// read as "no claim", which is what keeps an older checkout green until its
+// next update rather than failing it for a record it never had.
+function readDigests(value: unknown): Record<string, string> {
+  if (!isObject(value)) return {};
+  const digests: Record<string, string> = {};
+  for (const [path, digest] of Object.entries(value)) if (isString(digest)) digests[path] = digest;
+  return digests;
+}
+
+/// The digest orly records for content it wrote, and recomputes to check it.
+export function contentDigest(bytes: Uint8Array): string {
+  return createHash(DIGEST_ALGORITHM).update(bytes).digest(DIGEST_ENCODING);
+}
+
 // What orly installed here, and whether the engine has moved since.
 export function staleVersion(config: RepoConfig, installedVersion: string): string | undefined {
   if (config.orly_version === installedVersion) return undefined;
@@ -152,9 +174,33 @@ export function managedDrift(targetRoot: string, config: RepoConfig): string[] {
     ...present
       .filter((relativePath) => ignored.has(relativePath))
       .map((relativePath) => `managed file is ignored by git: ${relativePath} — orly wrote it and a clone will not receive it; scope the .gitignore rule that excludes it`),
+    ...editedManaged(targetRoot, config, present),
   ].sort();
 }
 
+// A managed file whose CONTENT no longer matches what orly wrote.
+//
+// The half `managedDrift` was missing, and the gap was not theoretical: a
+// consuming repository added two checks straight to a materialised gate script,
+// the pack never learned them, and the next update deleted them — while doctor
+// reported green throughout, because it verified that the file EXISTED and
+// never that it still said what orly put there. A gate whose checks can be
+// removed under a passing verifier is not a gate.
+//
+// The remedy for a hit is deliberately not `orly update`: the local content may
+// be the better version, as it was in that case. Update overwrites it; the
+// message says to move the change into the source instead, which is the only
+// way it reaches every other consumer.
+function editedManaged(targetRoot: string, config: RepoConfig, present: string[]): string[] {
+  return present.flatMap((relativePath) => {
+    const recorded = config.digests[relativePath];
+    if (!recorded) return [];
+    const actual = contentDigest(readFileSync(join(targetRoot, relativePath)));
+    if (actual === recorded) return [];
+    return [`managed file was edited after orly wrote it: ${relativePath} — move the change into the pack source, or \`orly update\` to discard it`];
+  });
+}
+
 // Key order is fixed so a rewrite produces a reviewable diff: orly's own two
 // fields sit at the ends, the repository's three in the middle, untouched.
 export async function writeConfig(targetRoot: string, config: RepoConfig): Promise<string> {
@@ -168,6 +214,7 @@ export async function writeConfig(targetRoot: string, config: RepoConfig): Promi
     commands: config.commands,
     ...(config.surfaces ? { surfaces: config.surfaces } : {}),
     managed: [...config.managed].sort(),
+    digests: Object.fromEntries(Object.entries(config.digests).sort(([a], [b]) => a.localeCompare(b))),
   };
   await Bun.write(path, `${JSON.stringify(ordered, undefined, JSON_INDENT)}${NEWLINE}`);
   return path;
@@ -177,7 +224,7 @@ export async function writeConfig(targetRoot: string, config: RepoConfig): Promi
 // from what the repository already builds with; an empty set is honest rather
 // than wrong, and says so in the gate's own failure message.
 export async function seedConfig(targetRoot: string): Promise<RepoConfig> {
-  return { schema_version: CONFIG_SCHEMA_VERSION, orly_version: "", packs: [], commands: await sniffCommands(targetRoot), surfaces: undefined, managed: [] };
+  return { schema_version: CONFIG_SCHEMA_VERSION, orly_version: "", packs: [], commands: await sniffCommands(targetRoot), surfaces: undefined, managed: [], digests: {} };
 }
 
 // What this repository installed and runs with, read from its own `.oracle/`.

package/src/install.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, renameSy
 import { dirname, extname, join, relative, resolve } from "node:path";
 
 import { UNSCOPED_ENVIRONMENT } from "./git_env";
-import { CONFIG_PATH, readConfig, seedConfig, selectPacks, writeConfig } from "./config";
+import { CONFIG_PATH, contentDigest, readConfig, seedConfig, selectPacks, writeConfig } from "./config";
 import { applyMode, assertWritableInside, hashContent, isBelow, isString, JsonObject, modeLabel, objectArray, objectValue, OrlyError, RulesModel, stringArray } from "./model";
 import { AGENTS_FILENAME, GENERATED_BANNER, installLoaders, Layout, loaderTargets, ORLY_AGENTS_FILENAME } from "./loaders";
 import { referenceClosureErrors, renderProfileText } from "./references";
@@ -116,7 +116,16 @@ export async function install(model: RulesModel, options: InstallOptions): Promi
   skipped.push(...hooks.all.filter((path) => !hooks.written.includes(path)));
   // One file carries both halves: the repository's own fields pass through
   // untouched, orly's two record what this run installed and wrote.
-  await writeConfig(targetRoot, { ...config, orly_version: options.orlyVersion, managed: [...planned.map((file) => file.target), ...hooks.all] });
+  // Digests cover `planned` only. Hooks are managed — orly restores a missing
+  // one — but it does not always AUTHOR them: it refuses to overwrite a hook it
+  // did not write. Recording a digest for a file whose content belongs to the
+  // repository would report the repository's own edits as drift.
+  await writeConfig(targetRoot, {
+    ...config,
+    orly_version: options.orlyVersion,
+    managed: [...planned.map((file) => file.target), ...hooks.all],
+    digests: Object.fromEntries(planned.map((file) => [file.target, contentDigest(file.content)])),
+  });
   if (!existing) written.push(CONFIG_PATH);
   return { ok: true, packs, written: written.sort(), skipped: skipped.sort(), errors: [] };
 }
@@ -370,6 +379,11 @@ function retargetRulesCitations(text: string, orlyFile: string): string {
   return text
     .replaceAll(`](${AGENTS_FILENAME})`, `](${orlyFile})`)
     .replaceAll(`](../${AGENTS_FILENAME})`, `](../${orlyFile})`)
+    // The relative spelling first: `../AGENTS.md` contains `AGENTS.md`, so the
+    // bare rule below would rewrite its tail and leave the `../` stranded.
+    // Missing it is what rendered `[`../AGENTS.md`](../AGENTS.orly.md)` into
+    // four managed pages — a label naming one file over a link to another.
+    .replaceAll(`\`../${AGENTS_FILENAME}\``, `\`../${orlyFile}\``)
     .replaceAll(`\`${AGENTS_FILENAME}\``, `\`${orlyFile}\``);
 }