create-cmp-cli 0.24.0 → 0.25.0

package/template/qa/lib/spec-model.mjs

@@ -0,0 +1,262 @@
+// spec-model.mjs — the scanner's view of a stack: what a profile's `layout`
+// and `tiers` declarations become once the core has checked them.
+//
+// qa/lib/spec-coverage.mjs owns the MECHANIC — the clause grammar, the
+// citation binding window, coverage in both directions, tier-must-observe.
+// The profile owns the MODEL — where specs and sources live, what a citation
+// file looks like, which tiers exist and which can observe which promise
+// (docs/NORTH-STAR.md §6; AGNOSTIC-HARNESS-ARCHITECTURE.md §4.2 #1 and #4).
+// This module joins them: it builds one validated `model` object from a
+// profile, and it resolves that model from a project root for the callers
+// that only have a root — the console's Specs bridge, feature-brief's derived
+// doneness, the framework-check runner.
+//
+// Resolution is SYNCHRONOUS on purpose. Every root-only caller is a sync
+// function deep in a sync chain (approvals → feature-brief → scanCitations),
+// and the profile is plain ESM with no top-level await, so it is loaded with
+// `require()` — supported for ESM since Node 20.19 / 22.12 and sharing the
+// module cache with `import()`, so the lane and a sync reader see the same
+// instance. Node 18 and 20.18 are end-of-life; the engines floor says so.
+//
+// Two override rules, both deliberate:
+//   - the manifest's layout fields (`specs`, `citationRoots`) override the
+//     profile's, field by field — the same semantics the console applies, so
+//     an attached foreign repo that told `attach` where its tests are gets the
+//     same scan from both readers. A stamped app's manifest carries the
+//     profile's own values, so the override is the identity there.
+//   - there is NO fallback model. A profile that declares no `layout` or no
+//     `tiers` is refused by name at load; a root with no manifest is refused
+//     with the command that writes one. A scanner that guessed a layout would
+//     report honest-looking absences about files ten characters away.
+//
+// SINGLE SOURCE OF TRUTH: packages/harness/src/lib/spec-model.mjs in the
+// create-cmp repo. Vendored byte-identical into qa/lib/ — edit the package
+// source, then run `node scripts/sync-harness.mjs`.
+
+import { resolveHarnessManifest } from "./harness-manifest.mjs";
+import { loadProfileSync } from "./profile-loader.mjs";
+
+/** A clause's declared requirement name: `[tier: device]` → "device". One path segment of letters/digits/dashes. */
+export const TIER_NAME_RE = /^[a-z][a-z0-9-]*$/i;
+
+function isStringList(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((s) => typeof s === "string" && s.trim() !== "");
+}
+
+function relPathProblem(field, value) {
+  if (typeof value !== "string" || value.trim() === "") return `${field} must be a non-empty string`;
+  if (value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value)) return `${field} must be relative to the project root (got "${value}")`;
+  if (value.includes("\\")) return `${field} must use "/" separators (got "${value}")`;
+  if (value.split("/").some((seg) => seg === "..")) return `${field} may not escape the project root (got "${value}")`;
+  return null;
+}
+
+/**
+ * Every contract violation in a profile's `layout` and `tiers`, or [] when
+ * they are usable. Never throws; a caller prints all defects at once.
+ * @param {{layout?: unknown, tiers?: unknown}} profile
+ * @returns {string[]}
+ */
+/**
+ * The core's fallback grammar: Kotlin/JVM and JavaScript. It is a FALLBACK and
+ * not a default in the approving sense — `SpecModel.grammar.isDefault` records
+ * that a profile declared none of it, and the coverage scan says so out loud
+ * when nothing binds. A stack whose tests look like anything else declares its
+ * own `grammar` export; `create-cmp harness init` seeds one from the language
+ * it detects.
+ */
+/**
+ * THE GRAMMAR IS DECLARED, NEVER DEFAULTED. Until 2026-09-08 this constant held
+ * Kotlin's and JavaScript's test-declaration regexes as the core's FALLBACK, and
+ * `cmp` itself never declared a grammar — so every profile that forgot the
+ * export was graded with Kotlin's, silently. PATTERN: declaration over
+ * inference, the shape tree-sitter uses (one query per language, named
+ * captures). WHY IT WORKS: a required field cannot be silently wrong for the
+ * author who forgot it — the lane refuses by name. HOW IT FAILS: a copied regex
+ * from another language binds nothing or the wrong lines. WHAT WE DO: the Rule
+ * 0 instrument plants an unbound citation in THIS language and watches the
+ * grammar fail it by name; the coverage diagnostic prints "N markers seen, 0
+ * bound". The two fields below are language-neutral and may default.
+ */
+export const GRAMMAR_REQUIRED = Object.freeze(["citationMarker", "testDeclaration", "lineComment"]);
+export const GRAMMAR_DEFAULTS = Object.freeze({ blockComment: null, bindingWindow: 5 });
+
+/** A profile may declare a pattern as a RegExp or as a source string. */
+function regexOr(value, fallback) {
+  if (value instanceof RegExp) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      return new RegExp(value);
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+
+export function specDeclarationProblems(profile) {
+  const out = [];
+  const layout = profile?.layout;
+  const tiers = profile?.tiers;
+  if (!layout || typeof layout !== "object") out.push("layout must be an object");
+  else {
+    const p = relPathProblem("layout.specs", layout.specs);
+    if (p) out.push(p);
+    if (!isStringList(layout.citationRoots)) out.push("layout.citationRoots must be a non-empty list of project-relative paths");
+    else for (const r of layout.citationRoots) { const q = relPathProblem("layout.citationRoots[]", r); if (q) out.push(q); }
+    if (!isStringList(layout.citationExts) || !layout.citationExts.every((e) => e.startsWith("."))) out.push('layout.citationExts must be a non-empty list of file extensions, each starting with "."');
+    if (layout.sourceRoots != null) {
+      if (!isStringList(layout.sourceRoots)) out.push("layout.sourceRoots must be a non-empty list of project-relative paths");
+      else for (const r of layout.sourceRoots) { const q = relPathProblem("layout.sourceRoots[]", r); if (q) out.push(q); }
+    }
+    if (layout.buildDir != null) {
+      const q = relPathProblem("layout.buildDir", layout.buildDir);
+      if (q) out.push(q);
+    }
+    if (layout.flows != null) {
+      if (typeof layout.flows !== "object") out.push("layout.flows must be null or {dir, exts}");
+      else {
+        const q = relPathProblem("layout.flows.dir", layout.flows.dir);
+        if (q) out.push(q);
+        if (!isStringList(layout.flows.exts) || !layout.flows.exts.every((e) => e.startsWith("."))) out.push('layout.flows.exts must be a non-empty list of file extensions, each starting with "."');
+      }
+    }
+  }
+  if (!tiers || typeof tiers !== "object") out.push("tiers must be an object");
+  else {
+    if (!isStringList(tiers.names)) out.push("tiers.names must be a non-empty list of tier names");
+    const names = new Set(isStringList(tiers.names) ? tiers.names : []);
+    if (!Array.isArray(tiers.hostOnly) || !tiers.hostOnly.every((t) => names.has(t))) out.push("tiers.hostOnly must list tiers from tiers.names");
+    if (!tiers.satisfying || typeof tiers.satisfying !== "object") out.push("tiers.satisfying must map a requirement name to the tiers that satisfy it");
+    else {
+      for (const [req, list] of Object.entries(tiers.satisfying)) {
+        if (!TIER_NAME_RE.test(req)) out.push(`tiers.satisfying has an invalid requirement name "${req}"`);
+        if (!isStringList(list) || !list.every((t) => names.has(t))) out.push(`tiers.satisfying.${req} must list tiers from tiers.names`);
+      }
+    }
+    if (tiers.journey != null && !names.has(tiers.journey)) out.push("tiers.journey must be one of tiers.names (or null when this stack has no journey tier)");
+    if (typeof tiers.forFile !== "function") out.push("tiers.forFile(rel) must be a function returning the citing file's tier");
+  }
+  const grammar = profile?.grammar;
+  if (!grammar || typeof grammar !== "object") {
+    out.push("grammar is required — declare citationMarker, testDeclaration and lineComment for this stack's language; the core has no fallback grammar (`create-cmp harness init` seeds one per language)");
+  } else {
+    for (const f of GRAMMAR_REQUIRED) {
+      const v = grammar[f];
+      if (!(v instanceof RegExp) && !(typeof v === "string" && v.trim())) out.push(`grammar.${f} is required — a RegExp or a pattern string for this language`);
+      else if (typeof v === "string") {
+        // A pattern that does not compile used to fall back to Kotlin's. It is a
+        // declaration problem, named here, so the lane refuses before it grades.
+        try { new RegExp(v); } catch (err) { out.push(`grammar.${f} is not a valid pattern: ${err.message}`); }
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Build the scanner's model from a profile's declarations, applying manifest
+ * layout overrides field by field. Pure.
+ * @param {{id?: string, layout: object, tiers: object}} profile
+ * @param {{specs?: string, citationRoots?: string[]}} [overrides] manifest layout fields
+ * @returns {{ok: true, model: SpecModel} | {ok: false, reason: string}}
+ */
+export function specModelFrom(profile, overrides = {}) {
+  const problems = specDeclarationProblems(profile);
+  if (problems.length) {
+    return { ok: false, reason: `profile ${JSON.stringify(profile?.id ?? "?")} declares an unusable layout/tiers: ${problems.join("; ")}` };
+  }
+  const { layout, tiers } = profile;
+  const specsDir = typeof overrides.specs === "string" && overrides.specs.trim() ? overrides.specs : layout.specs;
+  const citationRoots = isStringList(overrides.citationRoots) ? [...overrides.citationRoots] : [...layout.citationRoots];
+  const flows = layout.flows ? { dir: layout.flows.dir, exts: [...layout.flows.exts] } : null;
+  return {
+    ok: true,
+    model: Object.freeze({
+      profileId: typeof profile.id === "string" ? profile.id : null,
+      specsDir,
+      citationRoots: Object.freeze(citationRoots),
+      citationExts: Object.freeze([...layout.citationExts]),
+      // Absent means "the citation roots are the source roots" — a profile that
+      // never distinguished them keeps working, and nothing is invented.
+      sourceRoots: Object.freeze(isStringList(layout.sourceRoots) ? [...layout.sourceRoots] : [...citationRoots]),
+      flows: flows ? Object.freeze(flows) : null,
+      buildDir: typeof layout.buildDir === "string" ? layout.buildDir : null,
+      // THE GRAMMAR — what a citation and a test declaration LOOK LIKE in this
+      // stack's language. Stage 0 moved names, paths and tier names into the
+      // profile and left this behind, which was the more dangerous half: a
+      // directory name that is wrong produces a refusal, and a grammar that is
+      // wrong produces a WRONG VERDICT. The core's fallbacks match Kotlin/JVM
+      // and JavaScript only, so a Python or Go project scanned with them finds
+      // every marker and binds none — every clause reads as uncited and the
+      // message points at the spec file, which is not the problem. Measured on
+      // a real Python adoption, 2026-09-05. Field-by-field override: a profile
+      // that declares only `testDeclaration` keeps the rest.
+      grammar: Object.freeze({
+        citationMarker: regexOr(profile.grammar?.citationMarker, null),
+        testDeclaration: regexOr(profile.grammar?.testDeclaration, null),
+        typeDeclaration: regexOr(profile.grammar?.typeDeclaration, null),
+        lineComment: regexOr(profile.grammar?.lineComment, null),
+        blockComment: Object.freeze(
+          profile.grammar?.blockComment && typeof profile.grammar.blockComment.open === "string" && typeof profile.grammar.blockComment.close === "string"
+            ? { open: profile.grammar.blockComment.open, close: profile.grammar.blockComment.close }
+            : GRAMMAR_DEFAULTS.blockComment,
+        ),
+        bindingWindow:
+          Number.isInteger(profile.grammar?.bindingWindow) && profile.grammar.bindingWindow > 0
+            ? profile.grammar.bindingWindow
+            : GRAMMAR_DEFAULTS.bindingWindow,
+        // Always false since 2026-09-08: there is no fallback to be running on.
+        // Kept as a field because two readers print it.
+        isDefault: false,
+      }),
+      tiers: Object.freeze({
+        names: Object.freeze([...tiers.names]),
+        hostOnly: Object.freeze([...tiers.hostOnly]),
+        satisfying: Object.freeze(Object.fromEntries(Object.entries(tiers.satisfying).map(([k, v]) => [k, Object.freeze([...v])]))),
+        journey: tiers.journey ?? null,
+        forFile: (rel) => {
+          const t = tiers.forFile(rel);
+          return typeof t === "string" && t ? t : "other";
+        },
+      }),
+    }),
+  };
+}
+
+/**
+ * The model for a project root: manifest → profile (sync) → declarations,
+ * with the manifest's layout fields overriding the profile's.
+ * @param {string} root
+ * @returns {{ok: true, model: SpecModel} | {ok: false, reason: string}}
+ */
+export function resolveSpecModel(root) {
+  const manifest = resolveHarnessManifest(root);
+  if (!manifest.ok) return { ok: false, reason: manifest.reason };
+  const loaded = loadProfileSync(root, manifest.manifest.profile);
+  if (!loaded.ok) return { ok: false, reason: loaded.reason };
+  return specModelFrom(loaded.profile, { specs: manifest.manifest.specs, citationRoots: manifest.manifest.citationRoots });
+}
+
+/**
+ * resolveSpecModel for callers with no refusal channel: throws the reason.
+ * @param {string} root
+ * @returns {SpecModel}
+ */
+export function requireSpecModel(root) {
+  const r = resolveSpecModel(root);
+  if (!r.ok) throw new Error(r.reason);
+  return r.model;
+}
+
+/**
+ * @typedef {object} SpecModel
+ * @property {string|null} profileId
+ * @property {string} specsDir
+ * @property {readonly string[]} citationRoots
+ * @property {readonly string[]} citationExts
+ * @property {readonly string[]} sourceRoots
+ * @property {{dir: string, exts: readonly string[]}|null} flows
+ * @property {string|null} buildDir
+ * @property {{names: readonly string[], hostOnly: readonly string[], satisfying: Record<string, readonly string[]>, journey: string|null, forFile: (rel: string) => string}} tiers
+ */

package/template/qa/lib/step-cache.mjs

@@ -38,7 +38,16 @@ import fs from "node:fs";
 import path from "node:path";
 
 export const STEP_CACHE_REL_PATH = "composeApp/build/.cmp-step-cache.json";
-export const STEP_CACHE_SCHEMA = "cmp-step-cache/1";
+export const STEP_CACHE_SCHEMA = "prooflane-step-cache/1";
+
+/**
+ * Schema names a cache file may carry. Unlike the comments ledger, nothing here
+ * is at stake but time: an unrecognised schema makes `loadStepCache` return an
+ * EMPTY cache, which is correct — a cache you cannot read is a cache you do not
+ * have. Accepting the old name only spares every existing adopter one needless
+ * cold rebuild on the run after they upgrade.
+ */
+export const STEP_CACHE_SCHEMAS = Object.freeze(["cmp-step-cache/1", STEP_CACHE_SCHEMA]);
 
 function toPosix(p) {
   return p.split(path.sep).join("/");
@@ -116,7 +125,7 @@ export function computeStepInputsHash(root, inputs) {
 export function loadStepCache(root) {
   try {
     const parsed = JSON.parse(fs.readFileSync(path.join(root, STEP_CACHE_REL_PATH), "utf8"));
-    if (!parsed || parsed.schema !== STEP_CACHE_SCHEMA || typeof parsed.steps !== "object" || parsed.steps === null || Array.isArray(parsed.steps)) {
+    if (!parsed || !STEP_CACHE_SCHEMAS.includes(parsed.schema) || typeof parsed.steps !== "object" || parsed.steps === null || Array.isArray(parsed.steps)) {
       return { schema: STEP_CACHE_SCHEMA, steps: {} };
     }
     return { schema: STEP_CACHE_SCHEMA, steps: parsed.steps };

package/template/qa/lib/step-outcomes.mjs

@@ -10,7 +10,7 @@
 // the step — a gate that misattributes its own failures corrodes the gates that
 // are right.
 //
-// Pure, so the wording and the rule are testable without Gradle or a device.
+// Pure, so the wording and the rule are testable without a build tool or a device.
 // (docs/proposals/evidence-economics.md C3, S4.)
 //
 // FOUR VERDICTS. PASS / FAIL / SKIP had no way to say "I could not run": a
@@ -24,47 +24,6 @@
 // TIMEOUT vs FAILED, pytest's error vs failed — the distinction every mature
 // runner makes and this one did not.
 
-/**
- * The androidChecks outcome from Gradle's exit and the JUnit summary.
- *
- * @param {{ok: boolean, out: string}} res the Gradle invocation
- * @param {{tests: number, failures: number, errors: number}|null} summary parsed JUnit
- *   results, or null when none were written
- * @param {{gradlew?: string}} [opts]
- * @returns {{verdict: "PASS"|"FAIL"|"ERROR", executed: boolean, reason?: string}}
- */
-export function androidChecksOutcome(res, summary, { gradlew = "./gradlew" } = {}) {
-  const executed = Boolean(summary && summary.tests > 0);
-  if (res.ok) return { verdict: "PASS", executed };
-  const tail = String(res.out ?? "")
-    .split("\n")
-    .filter((l) => /FAILED|error:|failed/i.test(l))
-    .slice(0, 12)
-    .join("\n");
-  if (executed) {
-    return {
-      verdict: "FAIL",
-      executed,
-      reason:
-        `connectedDebugAndroidTest failed (${summary.failures + summary.errors} of ${summary.tests} tests) — ` +
-        `an on-device behavior claim is broken. Fix the behavior, not the test:\n${tail}`,
-    };
-  }
-  // ERROR, not FAIL: the step could not execute. A device tier that could not
-  // run is not evidence (the lane still FAILs), and going green would be the
-  // worse lie — but "your behaviour is broken" is withdrawn, and the receipt
-  // can tell a red that measured something from a red that measured nothing.
-  return {
-    verdict: "ERROR",
-    executed,
-    reason:
-      "connectedDebugAndroidTest DID NOT EXECUTE — the run reported no tests at all, so this step has observed " +
-      "nothing about your change and is not accusing it. Usual cause: another adb/Gradle session touching the same " +
-      "device (a manual `adb` command, a second lane, a running preview), or an install that never landed. " +
-      `Re-run this step alone with nothing else on the device before suspecting the code:\n  ${gradlew} :composeApp:connectedDebugAndroidTest --rerun\n${tail}`,
-  };
-}
-
 /** Thrown by the lane's subprocess helper when a step's deadline passes. */
 export class StepTimeout extends Error {
   constructor(cmd, deadlineMs) {
@@ -88,15 +47,69 @@ export function spawnTimedOut(res) {
   return res.signal === "SIGTERM" && (res.status === null || res.status === undefined);
 }
 
+/**
+ * The bounds a pack gets when it declares none.
+ *
+ * These were the rule. "Never under five minutes, never over thirty" is a
+ * judgement about how long a build can honestly take before it is wedged, and
+ * it was made once, for one toolchain: a cold `xcodebuild`, a cold `cargo test`
+ * against an empty target dir, or a Gradle daemon starting on a cold CI runner
+ * can each exceed thirty minutes honestly — and the lane killed the step and
+ * wrote an ERROR row, which is a wrong verdict about a healthy build.
+ *
+ * `stepDeadlineMs` always accepted overrides. Nothing supplied them: there was
+ * no channel from the profile to the call, so the numbers were unreachable from
+ * the only place that knows the stack. That was the defect, not the constants —
+ * which is why they survive here as a fallback rather than being replaced by a
+ * different guess.
+ */
+export const DEFAULT_STEP_DEADLINES = Object.freeze({ floorMs: 5 * 60_000, ceilingMs: 30 * 60_000 });
+
+/** A positive, finite number of milliseconds, or null. */
+function msOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null;
+}
+
+/**
+ * Resolve a pack's declared deadline bounds against the fallback.
+ *
+ * A malformed declaration is refused into the fallback rather than trusted: a
+ * deadline is the one number where believing a bad value either kills a healthy
+ * build or lets a wedged one run forever. This mirrors how the spine treats
+ * every other pack field — duck-typed and degrading — except that here the
+ * degradation is TOLD to the adopter, because `isDefault` reaches the ERROR row.
+ *
+ * `isDefault` is true only when NOTHING usable was declared. A pack that named
+ * one bound has made a choice and is not lectured about the other.
+ *
+ * @param {{floorMs?: number, ceilingMs?: number}|null|undefined} declared
+ * @returns {{floorMs: number, ceilingMs: number, isDefault: boolean}}
+ */
+export function resolveStepDeadlines(declared) {
+  const floor = declared && typeof declared === "object" ? msOrNull(declared.floorMs) : null;
+  const ceiling = declared && typeof declared === "object" ? msOrNull(declared.ceilingMs) : null;
+  return {
+    floorMs: floor ?? DEFAULT_STEP_DEADLINES.floorMs,
+    ceilingMs: ceiling ?? DEFAULT_STEP_DEADLINES.ceilingMs,
+    isDefault: floor === null && ceiling === null,
+  };
+}
+
 /**
  * A step's own deadline, from the journal's last measured duration for it:
- * three times what it usually takes, never under five minutes (a cold Gradle
- * daemon is slow, not wedged), never over thirty (past that it IS wedged).
+ * three times what it usually takes, never under the pack's floor (a cold build
+ * daemon is slow, not wedged), never over its ceiling (past that it IS wedged).
  * Unknown steps get the ceiling — a first run is never cut short.
+ *
+ * A floor above the ceiling is incoherent and the CEILING wins, because `min`
+ * is the outer operation: cutting a healthy step short is the failure this
+ * mechanism exists to avoid, so an incoherent declaration errs toward waiting.
+ *
  * @param {number|null|undefined} expectedMs
+ * @param {{floorMs?: number, ceilingMs?: number}} [bounds] the pack's, via resolveStepDeadlines
  * @returns {number}
  */
-export function stepDeadlineMs(expectedMs, { floorMs = 5 * 60_000, ceilingMs = 30 * 60_000 } = {}) {
+export function stepDeadlineMs(expectedMs, { floorMs = DEFAULT_STEP_DEADLINES.floorMs, ceilingMs = DEFAULT_STEP_DEADLINES.ceilingMs } = {}) {
   if (!(expectedMs > 0)) return ceilingMs;
   return Math.min(ceilingMs, Math.max(floorMs, Math.round(expectedMs * 3)));
 }
@@ -106,122 +119,42 @@ export function stepDeadlineMs(expectedMs, { floorMs = 5 * 60_000, ceilingMs = 3
  * out of the step's own body (which used to crash the whole lane; now it is
  * one ERROR row and the lane keeps going, because the other steps' verdicts
  * are still worth having).
+ * WHERE TO LOOK is the pack's to say, never the spine's: this used to end with
+ * "check `./gradlew --status` and `adb devices`", which is confident wrong
+ * advice in a repo that has neither. A pack marks a step with `fn.timeoutHint`
+ * (the same mechanism as `fn.layer`) and the runner passes it through; with no
+ * hint the message says what it honestly knows and stops.
+ *
  * @param {string} name the step's display name
  * @param {unknown} err
  * @param {number} durationMs
+ * HOW LONG TO WAIT is the pack's too, and when it has not said, the row says
+ * so. A killed step used to give an adopter no way to learn the bound existed —
+ * let alone that it was another stack's number — so a cold `xcodebuild` looked
+ * like a wedged build rather than a knob nobody had turned.
+ *
+ * @param {{hint?: string, deadlineWasDefault?: boolean}} [opts] `hint` — the pack's own
+ *        where-to-look sentence; `deadlineWasDefault` — the bound was inherited, so name the knob
  * @returns {{name: string, verdict: "ERROR", reason: string, durationMs: number, details: {executed: false, kind: string}}}
  */
-export function stepErrorResult(name, err, durationMs) {
+export function stepErrorResult(name, err, durationMs, { hint, deadlineWasDefault = false } = {}) {
   const timeout = err instanceof StepTimeout;
+  const where = typeof hint === "string" && hint.trim() ? ` ${hint.trim()}` : "";
+  const knob = deadlineWasDefault
+    ? ` This deadline is the spine's fallback, not a number this stack chose — if the step was healthy and simply slow, declare \`stepDeadlines: { ceilingMs }\` on the step pack.`
+    : "";
   const reason = timeout
-    ? `DID NOT COMPLETE — no result within its deadline (${Math.round(err.deadlineMs / 60000)} min). This step has observed nothing about your change and is not accusing it. ` +
-      `A wedged Gradle daemon or a device that stopped answering are the usual causes; check \`./gradlew --status\` and \`adb devices\`, then re-run the step alone.
+    ? `DID NOT COMPLETE — no result within its deadline (${Math.round(err.deadlineMs / 60000)} min). This step has observed nothing about your change and is not accusing it.${where}${knob} ` +
+      `Re-run the step alone before suspecting the code.
   ${err.cmd}`
     : `DID NOT RUN — the step threw before producing a verdict: ${err && err.message ? err.message : String(err)}. ` +
       `Nothing here is a claim about your change.`;
   return { name, verdict: "ERROR", reason, durationMs, details: { executed: false, kind: timeout ? "deadline" : "threw" } };
 }
 
-// ── Maestro directory run → per-flow outcome ────────────────────────────────
-/**
- * Parse Maestro's JUnit report (`maestro test <dir> --format junit --output f`)
- * into one row per flow. Tolerant: a report that is missing or unparsable
- * returns null and the caller falls back to the exit code — never a fabricated
- * per-flow list.
- * @param {string|null} xml
- * @returns {Array<{flow: string, ok: boolean, message?: string}>|null}
- */
-export function parseMaestroJunit(xml) {
-  if (typeof xml !== "string" || !/<testcase\b/.test(xml)) return null;
-  const rows = [];
-  const caseRe = /<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
-  let m;
-  while ((m = caseRe.exec(xml))) {
-    const attrs = m[1] || "";
-    const body = m[2] || "";
-    const name = (attrs.match(/\bname="([^"]*)"/) || [])[1] ?? (attrs.match(/\bid="([^"]*)"/) || [])[1] ?? "?";
-    const status = (attrs.match(/\bstatus="([^"]*)"/) || [])[1];
-    const failed = /<(failure|error)\b/.test(body) || (status && !/^(SUCCESS|PASSED?|OK)$/i.test(status));
-    const message = failed ? ((body.match(/<(?:failure|error)\b[^>]*message="([^"]*)"/) || [])[1] ?? body.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 300)) : undefined;
-    rows.push(failed ? { flow: name, ok: false, message } : { flow: name, ok: true });
-  }
-  return rows.length ? rows : null;
-}
-
-/**
- * The e2e step's verdict from the Maestro run: exit code + per-flow report +
- * the list of flows the directory held. FAIL names every failing flow; a run
- * whose report lists fewer flows than the directory holds is ERROR — the lane
- * cannot claim flows it has no row for.
- * @param {{ok: boolean, out: string}} res
- * @param {Array<{flow: string, ok: boolean, message?: string}>|null} perFlow
- * @param {string[]} flows root-relative flow files the directory holds
- * @returns {{verdict: "PASS"|"FAIL"|"ERROR", reason?: string, details: object}}
- */
-export function maestroOutcome(res, perFlow, flows) {
-  const details = { flows, results: perFlow ?? undefined };
-  if (perFlow) {
-    const failed = perFlow.filter((r) => !r.ok);
-    if (failed.length) {
-      return {
-        verdict: "FAIL",
-        reason: `Maestro: ${failed.length} of ${perFlow.length} flow${perFlow.length === 1 ? "" : "s"} failed — ${failed.map((r) => `${r.flow}${r.message ? ` (${r.message.split("\n")[0].slice(0, 120)})` : ""}`).join("; ")}`,
-        details,
-      };
-    }
-    if (perFlow.length < flows.length) {
-      return {
-        verdict: "ERROR",
-        reason: `Maestro reported ${perFlow.length} flow${perFlow.length === 1 ? "" : "s"} but ${E2E_DIR_LABEL} holds ${flows.length} — the run did not cover every flow, so no verdict can be claimed for the rest`,
-        details,
-      };
-    }
-    if (!res.ok) {
-      return { verdict: "FAIL", reason: `Maestro exited non-zero with every flow reported green — treat as a run failure:\n${String(res.out).split("\n").slice(-10).join("\n")}`, details };
-    }
-    return { verdict: "PASS", details };
-  }
-  if (!res.ok) {
-    return { verdict: "FAIL", reason: `Maestro failed (no per-flow report was written):\n${String(res.out).split("\n").slice(-15).join("\n")}`, details };
-  }
-  return { verdict: "PASS", reason: "Maestro exited 0 but wrote no per-flow report — verdict from the exit code only", details };
-}
-const E2E_DIR_LABEL = "qa/e2e";
-
-// ── Device-log incidents, scoped to the app under test ──────────────────────
-/**
- * ANR / fatal-exception lines from `adb logcat -d -b system,crash,main` that
- * belong to one of `appIds` (an app's process may be `pkg` or `pkg:remote`).
- * An emulator carries other apps — on 2026-09-03 the first self-booted lane
- * went red on `ANR in com.karel.bratometer` while driving com.fleet.check —
- * so an incident in another package is NOT this lane's failure. With no
- * appIds known the sweep stays unscoped (every incident counts) and says so.
- * @param {string} log
- * @param {string[]} appIds
- * @returns {{lines: string[], scoped: boolean}}
- */
-export function deviceLogIncidents(log, appIds = []) {
-  const lines = String(log ?? "").split("\n");
-  const ids = appIds.filter((id) => typeof id === "string" && id.trim() && id !== "__PACKAGE__");
-  const scoped = ids.length > 0;
-  const ours = (proc) => !scoped || ids.some((id) => proc === id || proc.startsWith(`${id}:`));
-  const out = [];
-  lines.forEach((line, i) => {
-    const anr = line.match(/ANR in (\S+?)(?:\s|,|$)/);
-    if (anr) {
-      if (ours(anr[1].replace(/[,)]$/, ""))) out.push(line);
-      return;
-    }
-    if (/FATAL EXCEPTION/i.test(line)) {
-      if (!scoped) {
-        out.push(line);
-        return;
-      }
-      // The crash buffer names the process on one of the next few lines.
-      const window = lines.slice(i, i + 8).join("\n");
-      const proc = window.match(/Process:\s*(\S+?)(?:,|\s|$)/);
-      if (proc && ours(proc[1])) out.push(line);
-    }
-  });
-  return { lines: out, scoped };
-}
+// The Maestro per-flow verdict and the device-log sweep moved to
+// qa/lib/profiles/cmp/maestro.mjs (Stage 0 PR 3); androidChecksOutcome moved to
+// qa/lib/profiles/cmp/android-checks.mjs (Stage 0 PR 6b.2). Facts about an
+// Android device, a Gradle task and an APK are a mobile profile's, not the
+// spine's. What is left here is neutral: deadlines, timeouts, and turning a
+// throw into one ERROR row.

package/template/qa/lib/walk.mjs

@@ -512,7 +512,7 @@ export function renderInject(data) {
   for (const a of arrivals)
     parts.push(`▲ ARRIVED, UNPLANNED — ${a.label} (${a.status}): ${a.reason ?? "no recorded reason"}. Offer: handle now, or after the current walk lands (recommended: after).`);
   parts.push(
-    "Protocol: open every reply with the chat header line above, verbatim. Speak stages as Decide·Design·Contract·Build·Prove·Sign-off — with their plain-words gloss on first mention — and clauses as promises. Declare the chain at kickoff and advance it as you go; if the studio line above says DOWN or not running, restore it (preview tool) or surface it before proceeding. Quiet between headers (one line per stage transition). At any human gate, render the full stop card: stage, what it is in plain words, then the easiest act first (the studio console when it is up; the CLI as fallback), then what comes after. Quote the lane's cost only from the measured figure in the card — never estimate it. Never open a second walk silently. Principles that bind THIS turn (docs/PRINCIPLES.md): derived, never claimed — name the command behind any claim; the layer you changed cannot certify itself — run its consumers, stamp a fresh app for a template or harness change; never wait on nothing — every wait is bounded, and if you are blocked, say on what and stop.",
+    "Protocol: open every reply with the chat header line above, verbatim. Speak stages as Decide·Design·Contract·Build·Prove·Sign-off — with their plain-words gloss on first mention — and clauses as promises. Declare the chain at kickoff and advance it as you go; if the studio line above says DOWN or not running, restore it (preview tool) or surface it before proceeding. Quiet between headers (one line per stage transition). At any human gate, render the full stop card: stage, what it is in plain words, then the easiest act first (the studio console when it is up; the CLI as fallback), then what comes after. Quote the lane's cost only from the measured figure in the card — never estimate it. Never open a second walk silently. Principles that bind THIS turn (create-cmp's docs/PRINCIPLES.md): derived, never claimed — name the command behind any claim; the layer you changed cannot certify itself — run its consumers, stamp a fresh app for a template or harness change; never wait on nothing — every wait is bounded, and if you are blocked, say on what and stop.",
   );
   return parts.join("\n\n");
 }

package/template/qa/preview-gallery.mjs

@@ -20,7 +20,7 @@ const previewsDir = resolve(
   process.argv[2] || join(HERE, "..", "composeApp", "build", "previews"),
 );
 
-const { renderTreeSvg } = await import(new URL("./lib/render.mjs", import.meta.url));
+const { renderTreeSvg } = await import(new URL("./lib/profiles/cmp/render.mjs", import.meta.url));
 const { auditA11y } = await import(new URL("./lib/a11y.mjs", import.meta.url));
 
 // The app's display name is read at RUNTIME from create-cmp.json, never stamped in.