pi-aia-asf 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -7,6 +7,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.2] - 2026-10-16
+
+### Added
+
+- **The model gate is now store-agnostic in fact, not just in intent.** It knew
+  SQL DDL and ORM cascade spellings and nothing else, so in a document, key-value,
+  wide-column or search store — where there is no constraint to declare a cascade
+  in — the gate was blind to the exact defect it exists to catch. A third rule,
+  `handwritten-cascade`, catches the cascade that exists only as code someone
+  wrote: a multi-delete driven by a reference to *another* entity.
+  - Covered by name: **MongoDB/Mongoose** (`deleteMany({ userId })`, including
+    ES6 shorthand), **Firestore** (`collectionGroup` / recursive subcollection
+    delete, where the field name is an argument, not a key), **DynamoDB**
+    (`DeleteItem` / `BatchWriteItem` keyed by a parent), **CouchDB** (`_deleted:
+    true` in a `bulkDocs`), **Redis** (the key-pattern wipe — the prefix *is* the
+    parent), **Elasticsearch** (`deleteByQuery` on a parent field). ORM
+    declarations were already matched: `CascadeType.REMOVE`/`ALL`,
+    `orphanRemoval`, `DeleteBehavior.Cascade`, Prisma/Sequelize `onDelete:
+    Cascade`, Django `on_delete=models.CASCADE`, Rails `dependent: :destroy` /
+    `:delete_all`, SQLAlchemy `cascade = "…delete…"`.
+  - **Near-miss fixtures guard the false-positive side**, because a rule that
+    fires on ordinary deletes gets switched off and the coverage goes with it:
+    deleting a row by its own identity, `updateMany` by reference, a Redis `del`
+    of one known key, a Firestore query on a plain field, a CouchDB bulk insert,
+    an ES delete-by-query on a non-reference, a DynamoDB point read — all clean.
+  - A fire asks for a **declaration**, it does not claim the ownership is wrong;
+    `model.handWrittenCascade: false` switches it off and
+    `model.extraHandWrittenPatterns` adds a project's own dialect (an invalid
+    regex is dropped, never fatal).
+  - `test-model-gate.mjs` grew from 73 to **92 checks**, and the assertion that
+    recorded this as a *documented gap* ("a hand-rolled document-store cascade is
+    not caught — invariant tests carry it") is now inverted to assert it **is**
+    caught. The production shape that started this — `deleteMany({ question_id:
+    { $in: ids } })` over a child collection — is the fixture.
+
+## [0.13.1] - 2026-10-16
+
+### Fixed
+
+- **A measurement without a target no longer reads as a verdict.** 0.13.0
+  shipped the measurement contract but left the last clause of the requirement
+  unimplemented: *where no defensible default exists the output is
+  `no-default: needs a declared target`, never a silent pass*. Now:
+  - **`perf.target` is the one parameter that ships no default.** A latency or
+    throughput target is a product decision; a number ASF invented would be a
+    fabricated specification. With nobody having declared one, the parameter
+    resolves to `value: null, origin: "no-default"` and the verdict text is the
+    literal `no-default: needs a declared target`.
+  - **`target` is required on latency and throughput claims.** A claim can carry
+    a complete measurement contract — percentile, load, samples, environment,
+    lab-or-field — and still be judging nothing. That is now reported, with
+    `noDefault` set on the result. A **regression** claim still needs no target:
+    it compares two arms rather than a threshold.
+  - **The parameter guard keeps its teeth.** The flag that exempts a parameter
+    from a band is the same flag that *forbids* it from shipping a general
+    default, so a fabricated number cannot smuggle itself in as "no default
+    needed". Adding `perf.target` also tripped the existing guard for a missing
+    `meaning` field — the guard working as intended on its first real test.
+  - `SKILL.md`/06k/06b state the rule where the contract is stated, and the
+    config screen shows `no-default` as a first-class origin.
+
 ## [0.13.0] - 2026-10-16
 
 ### Added

package/lib/code-health/config.mjs

@@ -48,9 +48,14 @@ export const DEFAULT_CONFIG = {
     enabled: true,
     requireDeclaration: true, // cascade requires an asf-model: declaration
     deleteRebuild: true, // delete + reinsert of the same target
+    // A cascade written by hand in a store with no FK action to inspect —
+    // MongoDB, Firestore, DynamoDB, CouchDB, Redis, Elasticsearch. Without it
+    // the model gate reads as SQL-only, which is the blind spot 06j §5 names.
+    handWrittenCascade: true,
     declarationWindowLines: 8,
     rebuildWindowLines: 30,
     extraCascadePatterns: [],
+    extraHandWrittenPatterns: [],
   },
 
   ignore: [
@@ -171,12 +176,17 @@ export function normalizeConfig(raw) {
       enabled: bool(md.enabled, d.model.enabled),
       requireDeclaration: bool(md.requireDeclaration, d.model.requireDeclaration),
       deleteRebuild: bool(md.deleteRebuild, d.model.deleteRebuild),
+      handWrittenCascade: bool(md.handWrittenCascade, d.model.handWrittenCascade),
       declarationWindowLines: num(md.declarationWindowLines, d.model.declarationWindowLines),
       rebuildWindowLines: num(md.rebuildWindowLines, d.model.rebuildWindowLines),
       extraCascadePatterns:
         Array.isArray(md.extraCascadePatterns) && md.extraCascadePatterns.length > 0
           ? md.extraCascadePatterns.filter((x) => typeof x === "string" && x.length > 0)
           : [],
+      extraHandWrittenPatterns:
+        Array.isArray(md.extraHandWrittenPatterns) && md.extraHandWrittenPatterns.length > 0
+          ? md.extraHandWrittenPatterns.filter((x) => typeof x === "string" && x.length > 0)
+          : [],
     },
     ignore: Array.isArray(raw.ignore) && raw.ignore.every((x) => typeof x === "string") && raw.ignore.length > 0
       ? raw.ignore

package/lib/code-health/model.mjs

@@ -39,6 +39,72 @@ const CASCADE_DECL_RES = [
   { marker: 'cascade = "…delete…"', re: /\bcascade\s*=\s*["'][^"']*delete/i },
 ];
 
+/**
+ * Hand-written cascades in stores that enforce nothing (P27, 06j §5).
+ *
+ * A relational FK action and an ORM mapping attribute at least announce
+ * themselves. In a document, key-value, wide-column or search store there is no
+ * constraint to declare, so the cascade exists only as code someone wrote —
+ * which is exactly where an instance silently inherits its parent's lifecycle.
+ * These patterns look for a MULTI-delete driven by a reference to another
+ * entity: the shape of "when the parent goes, these go too", implemented by
+ * hand and nowhere written down.
+ *
+ * Illustrative, not exhaustive: a project adds its own dialect with
+ * `extraHandWrittenPatterns`. A fire here asks for a declaration; it does not
+ * claim the ownership is wrong — that judgement stays in review.
+ */
+const HANDWRITTEN_CASCADE_RES = [
+  { marker: "MongoDB/Mongoose deleteMany by reference", store: "document", re: /\.(?:deleteMany|remove|bulkDelete|destroyAll)\s*\(/ },
+  {
+    // Firestore spells a field name as an argument, not as a key:
+    // `where('postId', '==', id)`. The recursive subcollection delete is the
+    // classic way an instance inherits its parent's lifecycle here, and there
+    // is no constraint to enforce it — so the reference is a quoted field name.
+    marker: "Firestore collectionGroup / recursive delete",
+    store: "document",
+    re: /\.collectionGroup\s*\(|\bdeleteCollectionGroup\b|\bdeleteDoc\b|\.where\s*\(/i,
+    refRe: /["'`][\w.]*?(?:Id|_id)["'`]/,
+  },
+  { marker: "DynamoDB batch/point delete", store: "wide-column", re: /\b(?:DeleteItem|BatchWriteItem|deleteItem|batchWrite)\b/ },
+  {
+    // CouchDB has no cascade either: a set of documents is selected and marked
+    // `_deleted` in one bulk write. The selection IS the ownership decision, so
+    // this dialect carries its own reference test (null = the marker suffices).
+    marker: "CouchDB bulk delete",
+    store: "document",
+    re: /_deleted\s*[:=]\s*true|\bbulkDocs\s*\([^)]*_deleted/i,
+    refRe: null,
+  },
+  {
+    // A key-pattern wipe is the key-value store's cascade: everything under the
+    // parent's prefix goes with it. The `*` is the reference — there is no key
+    // to look for, so this dialect carries its own.
+    marker: "Redis key-pattern wipe",
+    store: "key-value",
+    re: /\.(?:keys|scan)\s*\([^)]*\*|\b(?:del|unlink)\s*\(/i,
+    refRe: /["'`][^"'`]*\*|\b\w*(?:Id|_id)\b/,
+  },
+  { marker: "Elasticsearch delete-by-query", store: "search", re: /(?:\.|_)delete_?by_?\s*query\s*\(|\bdeleteByQuery\b/i },
+];
+
+/**
+ * A key that names ANOTHER entity rather than the row's own identity. This is
+ * what turns "a delete happened" into "a cascade was implemented by hand":
+ * `deleteOne({ id })` is a row removing itself, `deleteMany({ userId })` is one
+ * entity deciding the fate of another.
+ */
+const PARENT_REF_RE =
+  /(?:^|[{,(\s])(?!id\b|_id\b|pk\b|key\b|rowId\b|selfId\b)[A-Za-z][A-Za-z0-9]*(?:Id|_id)\s*[:=]/;
+
+/**
+ * The same reference written as ES6 object shorthand — `deleteMany({ userId })`
+ * rather than `deleteMany({ userId: userId })`. Extremely common, and anchored
+ * to a brace pair so a bare `orderId` sitting in an enclosing parameter list
+ * does not turn an unrelated delete into a finding.
+ */
+const PARENT_REF_SHORTHAND_RE = /\{[^{}]*\b(?!id\b|_id\b|pk\b|key\b|rowId\b|selfId\b)[A-Za-z][A-Za-z0-9]*(?:Id|_id)\b[^{}]*\}/;
+
 /** Writes and deletions, matched on verb shape rather than store dialect. */
 const DELETE_VERBS = /^(deleteMany|deleteOne|deleteAll|destroyAll|bulkDelete|delete|remove|removeAll|destroy)$/i;
 const INSERT_VERBS = /^(insertMany|insertOne|createMany|bulkCreate|bulkWrite|insert|insertAll|save|upsert|create)$/i;
@@ -96,6 +162,33 @@ export function extraCascadePatterns(cfg) {
   return out;
 }
 
+/**
+ * Project-supplied dialect for the hand-written-cascade rule, same contract as
+ * extraCascadePatterns: a bad regex is skipped, never fatal. A project whose
+ * store is not in the illustrative set adds its own spelling rather than
+ * waiting for a release.
+ */
+export function extraPatterns(list, markerPrefix) {
+  const out = [];
+  for (const p of list || []) {
+    if (typeof p !== "string" || !p) continue;
+    try {
+      out.push({ marker: `${markerPrefix}: ${p}`, store: "project-declared", re: new RegExp(p, "i") });
+    } catch {
+      /* invalid regex — ignore rather than crash the gate */
+    }
+  }
+  return out;
+}
+
+/** The collection/table a statement acts on, when it names one. */
+export function targetOfStatement(stmt) {
+  const named = /\b(?:collection|from|table|model|entity|index)\s*\(\s*["']([\w.\-]+)["']/i.exec(stmt);
+  if (named) return named[1];
+  const receiver = /(?:^|[\s;}])([A-Za-z_$][\w$]*)\s*(?:\.\s*(?:deleteMany|deleteOne|delete|remove|bulkDelete|destroyAll|deleteByQuery|bulkDocs|keys|scan|del|unlink|deleteItem|batchWrite)\s*\()/i.exec(stmt);
+  return receiver ? receiver[1] : null;
+}
+
 /** Distance in lines to the nearest preceding asf-model tag, or null. */
 export function nearestTag(lines, idx, windowLines) {
   for (let d = 0; d <= windowLines; d++) {
@@ -214,6 +307,38 @@ export function scanModelSource(relPath, text, cfg = {}) {
     }
   }
 
+  // ── F3: a cascade implemented by hand in a store that enforces nothing ───
+  //
+  // The store-agnostic half of the gate. MongoDB, Firestore, DynamoDB, CouchDB,
+  // Redis and Elasticsearch have no FK action to inspect, so "the parent takes
+  // the children" exists only as a delete someone wrote. Catching it here is
+  // the difference between a model gate that reads as SQL-only and one that
+  // actually asks the question wherever the defect can happen.
+  if (cfg.handWrittenCascade !== false) {
+    const handWritten = [...HANDWRITTEN_CASCADE_RES, ...extraPatterns(cfg.extraHandWrittenPatterns, "custom hand-written cascade")];
+    for (let i = 0; i < lines.length; i++) {
+      const hit = handWritten.find((c) => c.re.test(lines[i]));
+      if (!hit) continue;
+      // The delete must be driven by a reference to another entity, else every
+      // ordinary `deleteOne({ id })` in a Mongo project would fire. `refRe: null`
+      // means the dialect's own marker already carries that meaning.
+      const stmt = enclosingStatement(lines, i);
+      const refRe = hit.refRe === undefined ? PARENT_REF_RE : hit.refRe;
+      if (refRe && !refRe.test(stmt) && !PARENT_REF_SHORTHAND_RE.test(stmt)) continue;
+      if (nearestTag(lines, i, tagWindow)) continue;
+      const child = childTableAt(lines, i) || targetOfStatement(stmt);
+      findings.push({
+        rule: "handwritten-cascade",
+        file: relPath,
+        line: i + 1,
+        table: child,
+        marker: hit.marker,
+        store: hit.store,
+        message: `${hit.marker}${child ? ` over ${child}` : ""} deletes by a reference to another entity — in a ${hit.store} store nothing enforces that, so this IS the cascade decision. Add \`asf-model: ${child || "<child>"} -> <parent> = composition|instance|ledger, owner: <who>\` within ${tagWindow} lines above, or \`asf-model-accept: <reason>\` (06j §2, §5).`,
+      });
+    }
+  }
+
   return findings.sort((a, b) => a.line - b.line || a.rule.localeCompare(b.rule));
 }
 
@@ -268,4 +393,4 @@ export async function scanModel(root, { files, readFile, config } = {}) {
   return { findings, scanned, errors };
 }
 
-export const MODEL_RULES = ["undeclared-cascade", "delete-then-reinsert"];
+export const MODEL_RULES = ["undeclared-cascade", "delete-then-reinsert", "handwritten-cascade"];

package/lib/gates/config.mjs

@@ -79,9 +79,18 @@ export function assertParametersAreConsumed(projectConfig = {}, { knownGates } =
   for (const [k, spec] of Object.entries(PARAMS)) {
     if (!spec.gate) problems.push(`${k}: has no consuming gate`);
     if (!spec.source || !String(spec.source).trim()) problems.push(`${k}: has no source — a default that cannot explain itself is a guess with better formatting`);
-    if ((spec.band == null) !== !!spec.nonAdaptive) {
+    // A band exists to stop calibration widening a knob into an escape hatch.
+    // Two kinds of parameter have nothing to band: a non-adaptive constant (the
+    // general value is the only value), and a parameter with no general default
+    // at all — there is no number to drift. Anything else must carry one.
+    const unbanded = spec.band == null;
+    const exemptFromBand = !!spec.nonAdaptive || !!spec.requiresDeclaredTarget;
+    if (unbanded !== exemptFromBand) {
       problems.push(`${k}: a band requires adaptability, and a non-adaptive constant must not have one`);
     }
+    if (spec.requiresDeclaredTarget && spec.general !== null) {
+      problems.push(`${k}: declares requiresDeclaredTarget but ships a general default — that is the fabricated number this flag exists to prevent`);
+    }
   }
   return problems;
 }

package/lib/gates/defaults.mjs

@@ -25,7 +25,7 @@
  * guess with better formatting (02-research.md, P33).
  */
 
-/** @typedef {'default'|'project'|'calibrated'|'override'} ValueOrigin */
+/** @typedef {'default'|'project'|'calibrated'|'override'|'no-default'} ValueOrigin */
 
 /**
  * @typedef {object} ParamSpec
@@ -48,6 +48,25 @@
  * `.asf-test.json`.
  */
 export const PARAMS = {
+  // ── The one parameter that must NOT have a default (P33) ───────────────
+  //
+  // Every other parameter here can explain its own number. This one cannot, and
+  // inventing one is the failure the spec names: ASF must not decide that a
+  // consumer's endpoint is supposed to answer in 2s. With nobody having
+  // declared a target the verdict is `no-default: needs a declared target` —
+  // never a silent pass, and never a number ASF made up.
+  "perf.target": {
+    key: "perf.target",
+    general: null,
+    type: "string",
+    band: null,
+    requiresDeclaredTarget: true,
+    meaning: "The declared performance target a scenario is judged against; with no target declared there is no verdict, only a measurement",
+    source:
+      "no defensible general default exists — a latency or throughput target is a product decision, and a number ASF invented would be a fabricated specification (06i). It must be declared by the spec it comes from.",
+    gate: "measurement",
+  },
+
   // ── Performance placement (P34) ──────────────────────────────────────────
   "perf.cheapBudgetSeconds": {
     key: "perf.cheapBudgetSeconds",
@@ -291,6 +310,23 @@ export function resolveParam(key, tiers = {}) {
     nonAdaptive: !!spec.nonAdaptive,
   };
 
+  // A parameter with no defensible general default has exactly one legal
+  // output when nobody declared it: say so. Returning a value here would be the
+  // silent pass this branch exists to prevent, so an explicit project value or
+  // override is the only way it resolves.
+  if (spec.requiresDeclaredTarget) {
+    const declared =
+      Object.prototype.hasOwnProperty.call(overrides, key)
+        ? overrides[key]
+        : Object.prototype.hasOwnProperty.call(projectConfig, key)
+          ? projectConfig[key]
+          : null;
+    if (declared == null || declared === "") {
+      return { ...base, value: null, origin: "no-default", why: "no-default: needs a declared target" };
+    }
+    return { ...base, value: declared, origin: "project", why: "declared target" };
+  }
+
   // Non-adaptive: the general value is the only value. A project or an override
   // that tries to move it is reported, not obeyed — silently ignoring it would
   // let a config file look like it had changed the rules.

package/lib/gates/measurement.mjs

@@ -22,12 +22,12 @@
 
 export const CONTRACTS = {
   latency: {
-    required: ["percentile", "load", "samples", "environment", "labOrField"],
-    hint: "a latency claim needs a percentile, the load it was measured at, the sample count, the environment, and whether it is lab or field",
+    required: ["percentile", "load", "samples", "environment", "labOrField", "target"],
+    hint: "a latency claim needs a percentile, the load it was measured at, the sample count, the environment, whether it is lab or field, and the target it is being judged against",
   },
   throughput: {
-    required: ["arrivalModel", "duration", "environment", "samples"],
-    hint: "a throughput claim needs an arrival model (closed-loop vs open-loop — coordinated omission changes the answer), the duration, the environment and the sample count",
+    required: ["arrivalModel", "duration", "environment", "samples", "target"],
+    hint: "a throughput claim needs an arrival model (closed-loop vs open-loop — coordinated omission changes the answer), the duration, the environment, the sample count and the target it is being judged against",
   },
   regression: {
     required: ["comparison", "interleaved", "rawSamples", "cv", "samples", "environment"],
@@ -54,6 +54,14 @@ export function checkMeasurementContract(claim) {
   });
   const out = { ok: missing.length === 0, missing, claim };
   if (!out.ok) out.hint = contract.hint;
+  // A claim can carry a full measurement contract and still have nothing to be
+  // compared against. "p95 was 180ms at 200 users, 30 samples, CI" is a real
+  // measurement; without a target it is not a verdict about meeting anything.
+  // ASF does not invent the target — that is a product decision — so the
+  // verdict here is the literal string the spec names, never a silent pass.
+  if (missing.includes("target")) {
+    out.noDefault = "no-default: needs a declared target";
+  }
   return out;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-aia-asf",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Ai Applied Agentic Software Factory — codifies the full software development flow: intake, research, spec capture, adversarial analysis, planning with approval gates, test-first implementation, and release. Requires pi-vigilant, pi-smart-web-search, pi-smart-fetch, and pi-aia-browser.",
   "keywords": [
     "pi-package",

package/skills/aia-asf/references/06b-testing-qa.md

@@ -484,6 +484,12 @@ do not accept it, and do not quietly drop it.**
 | Throughput | arrival model (closed-loop or open-loop) · duration · environment · sample count |
 | Regression | statistical comparison · interleaved randomized measurement · retained raw samples · observed CV · sample count · environment |
 
+Latency and throughput claims additionally carry **the target they are judged
+against**. ASF ships no default for it (`perf.target` is the one parameter with
+no general default): with no declared target the output is
+`no-default: needs a declared target`, never a silent pass and never a number
+ASF invented — deciding a consumer's SLA is a product decision, not a default.
+
 Full text, rationale and the arrival-model trap:
 [06k-performance.md](06k-performance.md) §2. The DoD line *"performance targets
 from the spec are met"* is unfalsifiable without this — which is why it has

package/skills/aia-asf/references/06j-data-model.md

@@ -182,13 +182,38 @@ requirement: "is this ownership correct?" is judgment and stays in review, while
 defect is not SQL-shaped: an instance inheriting its parent's lifecycle happens
 in a relational FK action, in an ORM mapping attribute, in a document store's
 delete dependency, in a key-value prefix wipe, or in a loop someone wrote to
-delete children by hand. The scan recognises a small illustrative set of those
-spellings and a project adds its own dialect with `model.extraCascadePatterns`
-rather than waiting for a release. **Where the store has no constraint to
-inspect, the scan has nothing to attach to and the invariant tests below are the
-only hard gate** — say which of the two you relied on, and if the scan reported
-`scanned: 0`, say that too. A clean scan means the tripwire caught nothing, not
-that the model is sound.
+delete children by hand. Three rules run:
+`undeclared-cascade` (a cascade declaration with no ownership declaration),
+`delete-then-reinsert` (rebuild-by-delete over one table or collection), and
+`handwritten-cascade` — the store-agnostic half, for stores that have **no
+constraint to declare the cascade in the first place**:
+
+| Store family | What the cascade looks like when nobody wrote it down |
+|---|---|
+| **MongoDB / Mongoose** | `deleteMany({ userId })` over a child collection — no FK action exists, so this code *is* the cascade |
+| **Firestore** | a recursive `collectionGroup` / subcollection delete; missing a nested subcollection is the standard failure |
+| **DynamoDB** | `DeleteItem` / `BatchWriteItem` driven by a parent key across tables; GSI/LSI are wiped with the table, items are not |
+| **CouchDB** | documents selected and marked `_deleted: true` in one `bulkDocs` |
+| **Redis** | a key-pattern wipe — `keys('session:<id>:*')` then `del`/`unlink`; the prefix *is* the parent |
+| **Elasticsearch** | `deleteByQuery` on a parent field; no referential integrity exists to fall back on |
+
+ORM-level declarations are matched too — `CascadeType.REMOVE`/`ALL`,
+`orphanRemoval = true`, `DeleteBehavior.Cascade`, `onDelete: Cascade`
+(Prisma/Sequelize), `on_delete=models.CASCADE` (Django),
+`dependent: :destroy` / `:delete_all` (Rails), `cascade = "…delete…"`
+(SQLAlchemy) — so the gate is not SQL DDL only.
+
+A fire here asks for a **declaration**; it does not claim the ownership is
+wrong, which stays a judgement in review. A delete of a row by its own identity
+(`deleteOne({ _id: id })`) is not a cascade and does not fire — a rule that
+fires on ordinary deletes gets switched off, and the coverage goes with it.
+Projects add dialects with `model.extraCascadePatterns` and
+`model.extraHandWrittenPatterns` rather than waiting for a release.
+
+**Where the store has no constraint to inspect, the scan has nothing to attach
+to and the invariant tests below are the only hard gate** — say which of the two
+you relied on, and if the scan reported `scanned: 0`, say that too. A clean scan
+means the tripwire caught nothing, not that the model is sound.
 
 **Invariant and non-effect tests** — [06g-test-design.md](06g-test-design.md) §3:
 survival tests, non-effect assertions, zero-row invariant queries, two-user

package/skills/aia-asf/references/06k-performance.md

@@ -57,10 +57,17 @@ than accepted.
 **A number without its contract is not a specification. Report it as incomplete;
 do not accept it, and do not quietly drop it.**
 
+**And a measurement without a target is not a verdict.** ASF does not decide a
+consumer's SLA. `perf.target` is the one parameter in the table that ships **no
+default**, and with nobody having declared one the output is the literal string
+`no-default: needs a declared target` — never a silent pass, and never a number
+ASF made up. A perfectly well-formed measurement that has nothing to compare
+against has told you something and concluded nothing; say that.
+
 | Claim type | Required, all of it |
 |---|---|
-| **Latency** | percentile · load it was measured at · sample count · environment · lab or field |
-| **Throughput** | arrival model (closed-loop or open-loop) · duration · environment · sample count |
+| **Latency** | percentile · load it was measured at · sample count · environment · lab or field · **the target it is judged against** |
+| **Throughput** | arrival model (closed-loop or open-loop) · duration · environment · sample count · **the target it is judged against** |
 | **Regression** | statistical comparison · interleaved randomized measurement · retained raw samples · observed CV · sample count · environment |
 
 Wrong, and how it must be reported: