@agentsfleet/orly 0.10.5 → 0.10.7

package/llms.txt

@@ -36,17 +36,19 @@ Run from the repository root. Execute these in order and stop at the first
 non-zero exit.
 
 ```bash
-# 1. preview — writes nothing
-bunx @agentsfleet/orly init --dry-run
+# 1. install the executable used by Git hooks
+bun add -g @agentsfleet/orly
 
-# 2. install
-bunx @agentsfleet/orly init
+# 2. preview, then initialize
+orly init --dry-run
+orly init
 
-# 3. confirm installed state matches what orly would write today
-bunx @agentsfleet/orly doctor
+# 3. complete any reported setup items, then check configuration and files
+orly doctor
 ```
 
 Then commit the result. Teammates receive the rules on clone.
+Keep `orly` on `PATH`; hooks use the installed executable.
 
 IMPORTANT: git does not clone hooks. Each checkout must run `orly init` once.
 If a human reports that gates are not firing, this is the first thing to check.
@@ -67,8 +69,11 @@ If a human reports that gates are not firing, this is the first thing to check.
 | `.oracle/orly.json` | packs, gate commands, install record | shared — edit the commands |
 
 `orly init` seeds `.oracle/orly.json` with gate commands found in `Makefile` or
-`package.json`. If commands are missing, ask the user which ones to add. Do not
-invent check commands.
+`package.json`. Read the repository's build files to complete missing commands;
+ask only when the repository does not define a check. Do not invent commands.
+Declare `conform` and at least one named `verify.*` command. Documentation
+repositories can use `verify.docs` without application unit or integration
+suites. `init` reports missing configuration; `doctor` rejects it.
 
 ---
 
@@ -91,7 +96,7 @@ move it. `orly gate pr` reads where it ended up.
 ```
 docs/v1/pending/   spec written, committed on main
       │
-      │  CHORE(open)   branch cut, baseline recorded, NO CODE until it commits
+      │  CHORE(open)   branch cut, comparison revision recorded, baseline measurement pending
       ▼
 docs/v1/active/    PLAN → EXECUTE → CONFORM → VERIFY → REVIEW → DOCUMENT → COMMIT
       │
@@ -117,14 +122,14 @@ Rules for you:
 | same gate fails twice on the same cause | stop, report the gate name and output to the user |
 | `orly init` refuses a file | orly did not write that file. Report it. Do **not** pass `--force` on your own initiative |
 | hooks not firing | run `git config core.hooksPath` and confirm `orly init` was run in this checkout |
-| gate command missing from `.oracle/orly.json` | ask the user for the command; do not invent one |
+| gate command missing from `.oracle/orly.json` | read the build files and declare the existing check; ask only if none exists |
 | `orly gate pr` red and the failure is genuinely inapplicable | ask the user; only they authorise `orly override` |
 | gstack `/review` unavailable | continue; orly records the skipped review in the PR notes |
 
 Overrides are recorded as an empty commit that rides into the Pull Request:
 
 ```bash
-bunx @agentsfleet/orly override <criterion> --reason "<why>"
+orly override <criterion> --reason "<why>"
 ```
 
 Never record an override without an explicit instruction from the user, and
@@ -155,7 +160,7 @@ never with a placeholder reason.
 | `orly gate` | run declared checks in order, stopping at the first failure |
 | `orly gate pr` | the Pull Request criteria check |
 | `orly override <criterion> --reason <why>` | record a gate exception (user-authorised only) |
-| `orly doctor` | diff installed state against what orly would write today |
+| `orly doctor` | check installed files and required command configuration |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsfleet/orly",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "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/registry.json

@@ -269,6 +269,10 @@
         {
           "source": "audits/spec-template.sh",
           "target": "audits/spec-template.sh"
+        },
+        {
+          "source": "audits/spec-template.ts",
+          "target": "audits/spec-template.ts"
         }
       ]
     },

package/skills/orly-spec-new/SKILL.md

@@ -74,6 +74,8 @@ This is the step that prevents greptile findings — the spec becomes a pre-comm
 - **Every Failure Mode → a negative test.** **Every Invariant → enforced by code** (compiler, lint, comptime assertion, runtime check) — never by review discipline.
 - **Every Metrics row → event/test proof.** User-facing or operator-facing specs declare product/operator signals, privacy guards, and analytics/funnel playbook updates; internal-only cleanup explicitly says no signal changed.
 - **Rubric = 5–12 outcome rows** — one per Section outcome, failure class, or hygiene gate (never per Dimension); each with a copy-paste Verify command and a mechanically checkable Expected (exit code / literal substring / match count). Standard rows come pre-filled in the template — prune to the touched surface.
+- **Stage-owned values** — keep branch and baseline measurement pending at authoring. Opening records the full comparison commit; unit and integration measurement is due before the Pull Request. The lifecycle dispatch owns command timing and hydration.
+- **Decision ownership** — identify agent choices, preparation outputs, and required human decisions. Human acceptance uses tier `manual` with a procedure and durable evidence; never invent the person's sign-off.
 - **Reporting spine** — **Discovery (consult log)** carries consults, skill-chain outcomes, and Indy-acked deferral quotes; the **Acceptance Rubric's Graded column** carries the VERIFY verdicts (✅/❌ + one decisive output line each). Both empty at creation, populated as work proceeds.
 
 → Fills **Sections (+ Dimensions)**, **Metrics & Observability**, **Failure Modes**, **Invariants**, **Test Specification (tiered)**, **Acceptance Rubric**, **Discovery**.
@@ -90,7 +92,7 @@ cp docs/TEMPLATE.md docs/v{N}/pending/M{N}_{WS}_P{P}_{CATEGORIES}_{NAME}.md
 ```
 
 
-**Fill grammar** — the template body is ordered for the *executing* agent (execution read order), not for authoring; fill sections in the order of Steps 1–3 above, not top-to-bottom. Replace every `{…}` slot with instance content, then **delete every `<!-- tpl: … -->` guidance comment** — the SPEC TEMPLATE GATE BLOCKs any survivor, unfilled slot sentinels, and missing required sections. The SPEC AUTHORING RULES banner is the one comment that stays.
+**Fill grammar** — the template body is ordered for the *executing* agent (execution read order), not for authoring; fill sections in the order of Steps 1–3 above, not top-to-bottom. Replace every `{{fill:description}}` authoring slot with instance content, then **delete every `<!-- tpl: … -->` guidance comment** — the SPEC TEMPLATE GATE BLOCKs any survivor, unfilled slot sentinels, and missing required sections. The SPEC AUTHORING RULES banner is the one comment that stays.
 
 **Inputs** — Milestone `M{N}` (next free, sortable) · Workstream `{WS}` zero-padded (`001`…) · Priority (**P0** blocking · **P1** customer/operator-facing · **P2** tooling · **P3** deferrable) · Category set alphabetised (`API` Zig/Go · `CLI` agentsfleet/Node · `UI` Next.js · `OBS` Grafana · `SKILL` SKILL.md · `INFRA` Terraform) · Name UPPER_SNAKE_CASE ≤6 words describing the outcome (`BUN_VENDOR_UTILITIES`, not `BUMP_BUN_DEPS`) · Prototype tag (`v1.0.0`, `v2.0.0` — drives `docs/v1/` vs `docs/v2/`).
 

package/skills/orly-write-integration-test/SKILL.md

@@ -69,7 +69,7 @@ Spec asserts "503 on Redis down", code returns 200 → test the spec, flag the c
 1. **Read the spec** — Failure Modes, Error Contracts, Concurrency Contracts, Resource Limits, Streaming Contracts tables are authoritative.
 2. **Read `docs/greptile-learnings/RULES.md`** — every rule maps to a regression test.
 3. **Bring up real deps** — `make up` (or stack equivalent). Verify health before writing tests.
-4. **Run the existing integration suite** — establish green baseline; rule out flakes before adding tests.
+4. **Follow lifecycle timing** — record the comparison revision at opening; measure full unit and integration baselines before the Pull Request. Run focused reproduction and Section proofs while implementing; first application hydration occurs at Section verification. `dispatch/lifecycle.md` owns the sequence.
 5. **Map the ordered request path** — list every dependency interaction in execution order, including repeated acquisitions of the same resource, plus every `catch`/`orelse`/`except`/`Err` in the chain. That list seeds T4 and its partial-completion matrix.
 
 ## Three execution modes

package/skills/orly-write-unit-test/SKILL.md

@@ -51,7 +51,7 @@ Spec contradicts runtime → surface the conflict before testing. Code contradic
 1. **Read the spec, then the code** — spec defines what to test; code is what gets tested. Don't let code shape expectations.
 2. **Read `docs/greptile-learnings/RULES.md`** — every rule is a regression test.
 3. **Detect the stack** from project files (`pyproject.toml`, `Cargo.toml`, `build.zig`, `package.json` + `react`/`bin`, `*.sh`, `openapi.yaml`).
-4. **Run the existing suite first** — establish the green baseline before adding tests.
+4. **Follow lifecycle timing** — record the comparison revision at opening; measure full unit and integration baselines before the Pull Request. Run focused reproduction and Section proofs while implementing; first application hydration occurs at Section verification. `dispatch/lifecycle.md` owns the sequence.
 5. **Follow existing naming and fixture conventions.**
 
 ## Step 0 — the diff is the spec: build the required-test ledger first

package/src/cli.ts

@@ -9,6 +9,7 @@ import { isString, OrlyError, readJsonObject, RulesModel } from "./model";
 import { Renderer } from "./render";
 import { beginTelemetry, installedOrlyVersion, isTelemetrySkill, recordTelemetry } from "./telemetry";
 import { verifyRenders, writeEvidence } from "./verify";
+import { commandSetupErrors } from "./validation";
 
 type CliResult = { exitCode: number; gate?: string; failedCriterion?: string };
 
@@ -152,15 +153,18 @@ async function materialise(model: RulesModel, args: string[], isInit: boolean):
     installHooks: !args.includes(NO_HOOKS_FLAG),
     orlyVersion: await packageVersion(model),
   });
-  if (args.includes(JSON_FLAG)) console.log(JSON.stringify(result, undefined, JSON_INDENT));
-  else printInstall(result);
+  const setupErrors = result.ok ? commandSetupErrors((await readConfig(targetRoot))!.commands) : [];
+  if (args.includes(JSON_FLAG)) console.log(JSON.stringify({ ...result, setupErrors }, undefined, JSON_INDENT));
+  else printInstall(result, setupErrors);
   return result.ok ? 0 : 1;
 }
 
-function printInstall(result: InstallResult): void {
+function printInstall(result: InstallResult, setupErrors: string[]): void {
   for (const error of result.errors) console.log(`${FAIL_GLYPH} ${error.path}: ${error.message} — ${error.suggestion}`);
   if (!result.ok) return;
   console.log(`${PASS_GLYPH} ${result.written.length} written, ${result.skipped.length} already current (${result.packs.length} packs)`);
+  for (const error of setupErrors) console.log(`🟠 setup incomplete: ${error}`);
+  if (setupErrors.length > 0) console.log("Then run orly doctor to check the completed setup.");
 }
 
 function printGate(report: GateReport): void {
@@ -175,9 +179,6 @@ function projectRoot(): string {
 }
 
 async function doctorGlobal(model: RulesModel): Promise<number> {
-  // Every repository is the same case now: doctor reports on the ruleset
-  // installed where the caller is standing. There is no machine-level carrier
-  // to check — the rules ride in each repository's own commit.
   const errors = await doctorInstall(model);
   if (errors.length > 0) {
     for (const error of errors) console.log(`${FAIL_GLYPH} ${error}`);
@@ -188,7 +189,10 @@ async function doctorGlobal(model: RulesModel): Promise<number> {
     console.log(`${FAIL_GLYPH} no ${CONFIG_PATH} here — run \`orly init\` first`);
     return 1;
   }
-  console.log(`${PASS_GLYPH} this repository's installed ruleset matches ${CONFIG_PATH}`);
+  const setupErrors = commandSetupErrors(config.commands);
+  for (const error of setupErrors) console.log(`${FAIL_GLYPH} setup incomplete: ${error}`);
+  if (setupErrors.length > 0) return 1;
+  console.log(`${PASS_GLYPH} installed rules match ${CONFIG_PATH}; work and verification commands are declared`);
   return 0;
 }
 
@@ -266,12 +270,6 @@ function requireNoArguments(args: string[], usage: string): void {
   if (args.length > 0) throw new OrlyError(usage);
 }
 
-function optionValue(args: string[], name: string): string {
-  const value = optionalValue(args, name);
-  if (!value) throw new OrlyError(`${name} is required`);
-  return value;
-}
-
 function optionalValue(args: string[], name: string): string | undefined {
   const index = args.indexOf(name);
   return index < 0 ? undefined : args[index + 1];
@@ -301,10 +299,10 @@ Gates (read-only; no PR without every criterion green or a recorded override):
   orly gate <work|verify|pr>        run one gate
       work    does this commit conform? the declared conform command; no git
               state, so a commit hook's own dirty tree never blocks it
-      verify  does the work hold up? spec dimensions, docs language, and the
-              fast verify.* set
+      verify  does the work hold up? configuration, docs language, and the
+              non-test verify.* set; unfinished Sections may be pushed
       pr      can this ship? branch, tree, pushed, every spec criterion, and
-              the slow verify.* suites
+              every declared verify.* command
   orly override <CRITERION> --reason <REASON>
                                     empty commit with an Orly-Override trailer
 

package/src/criteria.test.ts

@@ -1,9 +1,10 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { rmSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 
 import { criteriaFor, runCommand } from "./criteria";
-import { cleanupTemporaryDirectories, modelFor, newRepository, newSpecRepository } from "./gates_test_support";
+import { activeSpecPath, closedSpecPath } from "./gates";
+import { cleanupTemporaryDirectories, closedSpecRepository, git, modelFor, newRepository, newSpecRepository } from "./gates_test_support";
 
 const WORK = "work";
 const VERIFY = "verify";
@@ -32,12 +33,12 @@ describe("criteriaFor", () => {
     expect(named(WORK, await contextFor(project))).toEqual(["cmd.conform", REPO_CONFIG]);
   });
 
-  test("verify pairs the spec dimensions with the fast command tier only", async () => {
+  test("verify permits unfinished Sections and excludes boundary test suites", async () => {
     const project = newSpecRepository();
     const names = named(VERIFY, await contextFor(project));
 
-    expect(names).toContain("spec.dimensions");
-    expect(names).toContain("cmd.verify.unit");
+    expect(names).not.toContain("spec.dimensions");
+    expect(names).not.toContain("cmd.verify.unit");
     // conform is the work gate's tier now, so the chain runs it once.
     expect(names).not.toContain("cmd.conform");
     // The slow tier belongs to the pr gate; leaking it here would make every
@@ -63,6 +64,20 @@ describe("criteriaFor", () => {
     expect(names).toContain("git.tree");
   });
 
+  test("final verification runs test lanes even when push verification never ran", async () => {
+    const root = newRepository();
+    const commands = Object.fromEntries(["unit", "integration", "memory", "lint"].map((lane) => [
+      `verify.${lane}`, [["sh", "-c", `echo ${lane} >> ran.txt`]],
+    ]));
+    const context = {
+      root, model: await modelFor(root, undefined, commands), acceptDirty: false,
+      surfaces: { changed: ["app.rs"], code: ["app.rs"], docs: [], userSurface: [] },
+    };
+    const checks = criteriaFor(PR, context).filter((entry) => entry.name.startsWith("cmd."));
+    expect(checks.map((entry) => entry.evaluate(context).ok)).toEqual([true, true, true, true]);
+    expect((await Bun.file(join(root, "ran.txt")).text()).trim().split("\n").sort()).toEqual(["integration", "lint", "memory", "unit"]);
+  });
+
   test("an unknown gate name yields no criteria rather than throwing", async () => {
     const project = newSpecRepository();
     expect(criteriaFor("nonsense", await contextFor(project))).toEqual([]);
@@ -108,14 +123,19 @@ describe("runCommand", () => {
     expect(runCommand(process.cwd(), ["true"])).toEqual({ ok: true, detail: "exit 0" });
   });
 
-  test("a non-zero exit carries the code and the last output line", () => {
+  test("a non-zero exit retains all output, including earlier findings", () => {
     const result = runCommand(process.cwd(), ["sh", "-c", "echo first; echo decisive >&2; exit 3"]);
 
     expect(result.ok).toBeFalse();
     expect(result.detail).toContain("exit 3");
+    expect(result.detail).toContain("first");
     expect(result.detail).toEndWith("decisive");
   });
 
+  test("a successful command retains its measured counts", () => {
+    expect(runCommand(process.cwd(), ["echo", "12 passed, 0 failed"]).detail).toContain("12 passed, 0 failed");
+  });
+
   test("a silent failure still reports a detail rather than an empty string", () => {
     const result = runCommand(process.cwd(), ["false"]);
 
@@ -146,3 +166,24 @@ describe("repo.config", () => {
     expect(verdict?.detail).toContain("orly init");
   });
 });
+
+describe("the final tree check", () => {
+  for (const stage of ["active", "done"]) {
+    test(`requires a ${stage} spec edit to be committed`, async () => {
+      const root = stage === "active" ? newSpecRepository() : closedSpecRepository("feat/spec");
+      const model = await modelFor(root);
+      const specPath = relative(root, activeSpecPath(root) ?? closedSpecPath(root)!);
+      const context = { root, model, specPath, acceptDirty: false };
+      const check = criteriaFor(PR, context).find((entry) => entry.name === "git.tree")!;
+      expect(check.evaluate(context).ok).toBe(true);
+
+      const path = join(root, specPath);
+      await Bun.write(path, `${await Bun.file(path).text()}\nUpdated evidence.\n`);
+      expect(check.evaluate(context).ok).toBe(false);
+      git(root, "add", specPath);
+      expect(check.evaluate(context).ok).toBe(false);
+      git(root, "commit", "-qm", "docs: record evidence");
+      expect(check.evaluate(context).ok).toBe(true);
+    });
+  }
+});

package/src/criteria.ts

@@ -12,6 +12,7 @@ import { documentationSurfaces, scanSurfaces } from "./doc_rules";
 import { isObject, JsonObject, objectValue, OrlyError, RulesModel } from "./model";
 import { readConfigSync, RepoConfig } from "./config";
 import { classifyBranch, SurfaceReport } from "./surfaces";
+import { commandSetupErrors } from "./validation";
 
 export type { Criterion, CriterionContext, CriterionResult, Verdict };
 export { runCommand };
@@ -22,6 +23,9 @@ const VERIFY_PREFIX = "verify.";
 const REPOSITORIES_LABEL = "repositories";
 const UNINSTALLED = "no .oracle/orly.json here — run `orly init` first";
 const REV_PARSE = "rev-parse";
+const HEAD = "HEAD";
+const UPSTREAM = "@{upstream}";
+const NEWLINE = "\n";
 const ABBREV_REF = "--abbrev-ref";
 const WORKTREE_LIST = ["worktree", "list", "--porcelain"];
 const WORKTREE_PREFIX = "worktree ";
@@ -47,37 +51,20 @@ const SLOW_TIER = "slow";
 // The slow tier is a fixed name set, not a prefix rule: lint and version
 // checks are verify.* too, and demoting them to skip-on-prose would be wrong.
 const SLOW_COMMANDS = ["verify.integration", "verify.memory"];
+const UNIT_COMMAND = "verify.unit";
+const ALL_TIER = "all";
 
-// Every criterion is mechanical: it reads an exit code or a file, never a
-// judgment. The anchor invariant promises the machine can PROVE the PR
-// boundary, so anything unprovable stays prose and never lands here.
-//
-// One gate per cadence, and each question asked at the only moment it can be
-// answered honestly:
-//
-//   work   — does this commit conform? Config plus the declared `conform`
-//            command. Nothing about branch or tree: inside a commit hook the
-//            tree is dirty BY CONSTRUCTION (that is what is being committed),
-//            and the operating model itself says a new spec is committed on the
-//            default branch. Judging either here made the generated pre-commit
-//            hook refuse every commit — including the one installing orly —
-//            with `--no-verify`, which Hard Safety forbids, as the only way out.
-//   verify — does the work hold up? Spec dimensions, documentation language,
-//            and the fast `verify.*` set. Runs before the work leaves the
-//            machine, not after every edit.
-//   pr     — can this ship? The whole-branch facts (branch shape, clean tree,
-//            pushed) plus every spec criterion and the slow suites. A tree is
-//            only required clean where a reviewer is about to read it, and a
-//            branch is only wrong for being `main` where a PR would open from
-//            it.
+// Commit checks read the index. Push checks permit in-flight Sections and omit
+// the boundary test suites. The final gate runs all declared verification
+// itself, including checks a custom repository hook may not have invoked.
 export function criteriaFor(gate: string, context: CriterionContext): Criterion[] {
   if (gate === "work") return [repositoryConfig(), ...commandCriteria(context, CONFORM_TIER)];
-  if (gate === "verify") return [specDimensions(), docsLanguage(), ...commandCriteria(context, FAST_TIER)];
+  if (gate === "verify") return [repositoryConfig(), docsLanguage(), ...commandCriteria(context, FAST_TIER)];
   if (gate === "pr") {
     return [
       gitBranch(), gitTree(), gitPushed(), specGate(), openQuestions(), productClarity(), specDimensions(),
       specMoved(), specBaseline(), specOrdering(), specDeferrals(),
-      docsUpdated(), ...commandCriteria(context, SLOW_TIER),
+      repositoryConfig(), docsLanguage(), docsUpdated(), ...commandCriteria(context, ALL_TIER),
     ];
   }
   return [];
@@ -93,14 +80,10 @@ function gitBranch(): Criterion {
 
 function gitTree(): Criterion {
   return criterion(GIT_TREE, (context) => {
-    // The active spec is excluded while work is in flight: Dimensions get
-    // marked DONE as the agent goes, and the tree check must not block on that
-    // bookkeeping. Committing the spec stays a CHORE(close) obligation.
     const dirty = gitOutput(context.root, ["status", "--porcelain=v1", "-uall"])
       .split(/\r?\n/)
-      .filter(Boolean)
-      .filter((line) => !context.specPath || !line.includes(context.specPath));
-    if (dirty.length === 0) return { ok: true, detail: "clean (active spec excluded)" };
+      .filter(Boolean);
+    if (dirty.length === 0) return { ok: true, detail: "clean" };
     if (context.acceptDirty) return { ok: true, detail: `${dirty.length} dirty path(s) accepted` };
     return { ok: false, detail: `${dirty.length} uncommitted path(s), first: ${dirty[0] ?? ""}` };
   });
@@ -108,11 +91,12 @@ function gitTree(): Criterion {
 
 function gitPushed(): Criterion {
   return criterion(GIT_PUSHED, (context) => {
-    const upstream = gitOutput(context.root, [REV_PARSE, ABBREV_REF, "--symbolic-full-name", "@{upstream}"]);
+    const upstream = gitOutput(context.root, [REV_PARSE, ABBREV_REF, "--symbolic-full-name", UPSTREAM]);
     if (upstream.length === 0) return { ok: false, detail: "branch has no upstream; push it first" };
-    const ahead = gitOutput(context.root, ["rev-list", "--count", "@{upstream}..HEAD"]);
-    const ok = ahead === "0";
-    return { ok, detail: ok ? `in sync with ${upstream}` : `${ahead} commit(s) not pushed to ${upstream}` };
+    const head = gitOutput(context.root, [REV_PARSE, HEAD]);
+    const remote = gitOutput(context.root, [REV_PARSE, UPSTREAM]);
+    const ok = head.length > 0 && head === remote;
+    return { ok, detail: ok ? `in sync with ${upstream}` : `HEAD differs from ${upstream}; push the reviewed revision` };
   });
 }
 
@@ -121,27 +105,23 @@ function repositoryConfig(): Criterion {
     try {
       const config = readConfigSync(context.root);
       if (!config) return { ok: false, detail: UNINSTALLED };
-      const commands = Object.keys(config.commands).length;
-      return { ok: commands > 0, detail: commands > 0 ? `${commands} command(s) declared` : "no commands declared in .oracle/orly.json — add conform and verify.* so the gate can run them" };
+      const errors = commandSetupErrors(config.commands);
+      return { ok: errors.length === 0, detail: errors.length > 0 ? errors.join("; ") : `${Object.keys(config.commands).length} command(s) declared` };
     } catch (error) {
       return { ok: false, detail: error instanceof Error ? error.message : String(error) };
     }
   });
 }
 
-// Model C: the repository's declared command surface. Orly owns policy and
-// invokes these; the repository owns what they actually do. Conform tier = the
-// `conform` command alone. Fast tier = every verify.* that is not slow. Slow
-// tier = verify.integration and verify.memory; those auto-pass with a printed
-// skip when the branch carries no code, so a prose-only branch never pays for
-// the slow suites.
+// Commands and source paths are repository-owned. Only integration and memory
+// checks are conditional on code; every other declared lane always runs.
 function commandCriteria(context: CriterionContext, tier: string): Criterion[] {
   const config = resolvedConfig(context);
-  if (!config) return tier === FAST_TIER ? [criterion(REPO_CONFIG, () => ({ ok: false, detail: UNINSTALLED }))] : [];
+  if (!config) return [];
   const commands = config.commands;
-  const selected = Object.keys(commands).filter((key) => tierOf(key) === tier).sort();
+  const selected = Object.keys(commands).filter((key) => tier === ALL_TIER ? key.startsWith(VERIFY_PREFIX) : tierOf(key) === tier).sort();
   return selected.map((key) => criterion(`cmd.${key}`, (inner) => {
-    if (tier === SLOW_TIER && report(inner, config.surfaces).code.length === 0) {
+    if (SLOW_COMMANDS.includes(key) && report(inner, config.surfaces).code.length === 0) {
       return { ok: true, detail: "skipped — no code files on this branch" };
     }
     return runInvocations(inner.root, commands[key]);
@@ -150,7 +130,7 @@ function commandCriteria(context: CriterionContext, tier: string): Criterion[] {
 
 function tierOf(key: string): string {
   if (key === CONFORM_COMMAND) return CONFORM_TIER;
-  if (SLOW_COMMANDS.includes(key)) return SLOW_TIER;
+  if (key === UNIT_COMMAND || SLOW_COMMANDS.includes(key)) return SLOW_TIER;
   if (key.startsWith(VERIFY_PREFIX)) return FAST_TIER;
   return "";
 }
@@ -213,12 +193,13 @@ function resolvedConfig(context: CriterionContext): RepoConfig | undefined {
 
 function runInvocations(root: string, invocations: unknown): Verdict {
   if (!Array.isArray(invocations) || invocations.length === 0) return { ok: false, detail: "command group is empty" };
+  const evidence: string[] = [];
   for (const invocation of invocations) {
     if (!Array.isArray(invocation) || invocation.length === 0) return { ok: false, detail: "command invocation is empty" };
     const argv = invocation.map((argument) => String(argument));
     const result = runCommand(root, argv);
-    if (!result.ok) return { ok: false, detail: `${argv.join(" ")} -> ${result.detail}` };
+    evidence.push(`${argv.join(" ")} -> ${result.detail}`);
+    if (!result.ok) return { ok: false, detail: evidence.join(NEWLINE) };
   }
-  return { ok: true, detail: `${invocations.length} invocation(s) exit 0` };
+  return { ok: true, detail: `${invocations.length} invocation(s) exit 0\n${evidence.join(NEWLINE)}` };
 }
-

package/src/criteria_spec.ts

@@ -1,5 +1,16 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { readConfigSync } from "./config";
 import { Criterion, CriterionContext, criterion, gitOutput, runCommand, Verdict } from "./criteria_support";
-import { branchDiff, defaultMergeBase } from "./surfaces";
+import { branchDiff, classifyBranch, defaultMergeBase } from "./surfaces";
+
+const BASELINE_HEADER = "Test Baseline";
+const REVISION_HEADER = "Baseline revision";
+const EVIDENCE_HEADER = "Baseline evidence";
+const BASELINE_LANES = ["unit", "integration"];
+const FULL_REVISION = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+const NOT_APPLICABLE = /^n\/a\s+[—-]\s+\S/i;
+
 
 const OPEN_QUESTION = "[?]";
 const PRODUCT_CLARITY_HEADING = "## Product Clarity";
@@ -17,7 +28,6 @@ const SPEC_BASELINE = "spec.baseline";
 const SPEC_ORDERING = "spec.ordering";
 const SPEC_DEFERRALS = "spec.deferrals";
 const STATUS_DONE = "Status: DONE";
-const BASELINE_HEADER = "Test Baseline:";
 const INDY_ACK = "> Indy (";
 // deferred/deferral(s) only — never Zig's defer/errdefer keywords.
 const DEFERRAL_CLAIM = /\bdeferr(ed|al|als)\b/i;
@@ -78,10 +88,29 @@ export function specMoved(): Criterion {
 
 export function specBaseline(): Criterion {
   return specCriterion(SPEC_BASELINE, (context) => {
-    const present = specLines(context).some((line) => line.includes(BASELINE_HEADER));
-    return present
-      ? { ok: true, detail: "Test Baseline recorded" }
-      : { ok: false, detail: `no \`${BASELINE_HEADER}\` line in the spec header — CHORE(open) records it before any code` };
+    const baseline = header(context.specText ?? "", BASELINE_HEADER);
+    if (!baseline) return { ok: false, detail: "no Test Baseline header — declare it at opening" };
+    let config;
+    try {
+      config = readConfigSync(context.root);
+    } catch (error) {
+      return { ok: false, detail: `cannot read baseline configuration: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (!config) return { ok: false, detail: "baseline needs the repository's declared commands" };
+    const lanes = BASELINE_LANES.filter((lane) => `verify.${lane}` in config.commands);
+    const surfaces = context.surfaces ?? classifyBranch(context.root, config.surfaces);
+    if (NOT_APPLICABLE.test(baseline)) {
+      const knownBase = defaultMergeBase(context.root).length > 0;
+      const allowed = lanes.length === 0 || (knownBase && surfaces.code.length === 0);
+      return { ok: allowed, detail: allowed ? "baseline not applicable: no code or no baseline lanes" : "n/a cannot replace a code branch's declared baseline lanes" };
+    }
+    for (const lane of lanes) {
+      if (!new RegExp(`(?:^|\\s)${lane}=\\d+(?=\\s|$)`).test(baseline)) {
+        return { ok: false, detail: `Test Baseline carries no count for ${lane} — measure before the Pull Request` };
+      }
+    }
+    if (lanes.length === 0) return { ok: false, detail: "no baseline lanes declared — record n/a with the reason" };
+    return baselineEvidence(context);
   });
 }
 
@@ -125,3 +154,21 @@ function specLines(context: CriterionContext): string[] {
 function dimensionLabels(lines: string[]): string {
   return lines.map((line) => line.trim().slice(DIMENSION_PREFIX.length).split("*")[0]?.trim() ?? "?").join(", ");
 }
+
+function baselineEvidence(context: CriterionContext): Verdict {
+  const text = context.specText ?? "";
+  const revision = header(text, REVISION_HEADER);
+  if (!FULL_REVISION.test(revision)) return { ok: false, detail: "Baseline revision must name a full comparison commit" };
+  const ancestor = gitOutput(context.root, ["merge-base", revision, "HEAD"]);
+  if (ancestor !== revision) return { ok: false, detail: "Baseline revision is missing or is not an ancestor of HEAD" };
+  const evidence = header(text, EVIDENCE_HEADER);
+  if (!evidence || (!/^https?:\/\/\S+$/.test(evidence) && !existsSync(resolve(context.root, evidence)))) {
+    return { ok: false, detail: "Baseline evidence must name an existing report or a run URL" };
+  }
+  return { ok: true, detail: "baseline counts, comparison revision, and evidence reference recorded; report contents require review" };
+}
+
+function header(text: string, name: string): string {
+  const prefix = `**${name}:**`;
+  return (text.split(/\r?\n/).find((line) => line.startsWith(prefix))?.slice(prefix.length).trim() ?? "").replaceAll("`", "");
+}

package/src/criteria_support.ts

@@ -41,10 +41,11 @@ export function runCommand(root: string, command: string[]): Verdict {
   } catch (error) {
     return { ok: false, detail: `${command[0] ?? "command"} could not be run: ${error instanceof Error ? error.message : String(error)}` };
   }
-  if (result.exitCode === 0) return { ok: true, detail: "exit 0" };
-  const merged = `${result.stdout.toString()}\n${result.stderr.toString()}`;
-  const lines = merged.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  return { ok: false, detail: `exit ${result.exitCode}: ${lines[lines.length - 1] ?? NO_OUTPUT}` };
+  const output = [result.stdout.toString(), result.stderr.toString()].filter(Boolean).join("\n").trim();
+  if (output) return { ok: result.exitCode === 0, detail: `exit ${result.exitCode}:\n${output}` };
+  return result.exitCode === 0
+    ? { ok: true, detail: "exit 0" }
+    : { ok: false, detail: `exit ${result.exitCode}: ${NO_OUTPUT}` };
 }
 
 export function gitOutput(root: string, command: string[]): string {

package/src/gates.test.ts

@@ -35,9 +35,9 @@ describe("gate groups", () => {
     const model = await modelFor(project);
 
     expect(names(runGate(model, project, "work"))).toEqual(["cmd.conform", "repo.config"]);
-    expect(names(runGate(model, project, "verify"))).toEqual(["cmd.verify.unit", "docs.language", "spec.dimensions"]);
+    expect(names(runGate(model, project, "verify"))).toEqual(["docs.language", "repo.config"]);
     expect(names(runGate(model, project, "pr"))).toEqual([
-      "docs.updated", "git.branch", "git.pushed", "git.tree", "spec.baseline", "spec.deferrals", "spec.dimensions",
+      "cmd.verify.unit", "docs.language", "docs.updated", "git.branch", "git.pushed", "git.tree", "repo.config", "spec.baseline", "spec.deferrals", "spec.dimensions",
       "spec.gate", "spec.moved", "spec.open-questions", "spec.ordering", "spec.product-clarity",
     ]);
   });