create-cmp-cli 0.11.0 → 0.13.0

package/template/qa/receipt-check.mjs

@@ -46,7 +46,25 @@ function evaluate() {
   if (receipt === null) {
     return { valid: false, reason: "no receipt — run `node qa/verify.mjs`", profile: undefined };
   }
-  return evaluateReceipt(receipt, () => computeInputsHash(ROOT));
+  // A fast-mode receipt (verify --fast) is an inner-loop signal, never done
+  // evidence — refused here before the hash is even recomputed, so a session
+  // can never end on "done" while its evidence trail's last run was --fast.
+  if (receipt.mode === "fast") {
+    return {
+      valid: false,
+      reason: "the last verify run was --fast (inner-loop only); run the full lane (`node qa/verify.mjs`) before finishing",
+      profile: receipt.profile,
+    };
+  }
+  const result = evaluateReceipt(receipt, () => computeInputsHash(ROOT));
+  // Surface the receipt's evidence rung (the ladder — qa/lib/evidence-level.mjs)
+  // alongside the verdict: the rung is the receipt's own derived field, read
+  // verbatim, never recomputed here. Older receipts without it stay valid.
+  const level = receipt.evidenceLevel;
+  if (level && typeof level === "object" && typeof level.rung === "string") {
+    result.evidenceLevel = level;
+  }
+  return result;
 }
 
 const result = evaluate();
@@ -65,10 +83,12 @@ if (asHook) {
   process.exit(0);
 }
 
+const rungSuffix = result.evidenceLevel ? ` — evidence ${result.evidenceLevel.rung} · ${result.evidenceLevel.name}` : "";
+
 if (asJson) {
   console.log(JSON.stringify(result, null, 2));
 } else if (result.valid) {
-  console.log(`VALID — ${result.reason}`);
+  console.log(`VALID — ${result.reason}${rungSuffix}`);
 } else {
   console.error(`INVALID — ${result.reason}`);
 }

package/template/qa/record-audit.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// Record that a cmp-audit of one androidMain subsystem happened — the
+// write half of the audit-cadence report (qa/lib/audit-cadence.mjs).
+//
+//   node qa/record-audit.mjs <subsystem> [--by <who-or-what>]
+//   node qa/record-audit.mjs --list
+//
+// Recording is a CLAIM — "this subsystem, as of this commit, was audited" —
+// so the entry's sha is derived from HEAD by the library, never passed in,
+// and the write is REFUSED when there is no git history, when the subsystem
+// is not one this app actually has (derived from the tree, printed on
+// refusal), or when the subsystem's files differ from HEAD (the record
+// would name a commit the audited bytes did not match — commit first).
+// Refusal over fabrication, the same stance as qa/approve.mjs.
+//
+// This CLI exists so the audit loop closes mechanically: the release
+// profile's receipt nudges "changed since last audit → cmp-audit <name>",
+// and the auditor's last act is this one command.
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { AUDITS_REL_PATH, ROOT_SUBSYSTEM, androidMainPackageRoot, evaluateAuditCadence, listSubsystems, recordAudit } from "./lib/audit-cadence.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const USAGE = `node qa/record-audit.mjs <subsystem> [--by <who-or-what>]
+
+Appends one audit record (subsystem, HEAD sha, ISO timestamp, recorder) to
+${AUDITS_REL_PATH}. The verify lane's release profile reports which
+subsystems changed since their last record. Subsystems are derived from the
+tree: the immediate package directories under the androidMain Kotlin source
+root ("${ROOT_SUBSYSTEM}" for files directly at the package root).
+
+  --list        print the derived subsystems and their audit status
+  --by <name>   who/what recorded this (default: git user.name)
+  --help, -h    this usage
+`;
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+  console.log(USAGE);
+  process.exit(args.length === 0 ? 2 : 0);
+}
+
+if (args.includes("--list")) {
+  const report = evaluateAuditCadence(ROOT);
+  if (!report.ok) {
+    console.log(report.reason);
+    process.exit(0);
+  }
+  console.log(`androidMain subsystems under ${report.packageRoot} (${report.summary}):`);
+  for (const s of report.subsystems) {
+    const when = s.audit?.at ? ` — last audit ${s.audit.at.slice(0, 10)} (${s.audit.sha.slice(0, 7)}, by ${s.audit.by ?? "unknown"})` : "";
+    console.log(`  ${s.name}: ${s.status}${when}`);
+  }
+  process.exit(0);
+}
+
+const byIdx = args.indexOf("--by");
+const by = byIdx >= 0 ? args[byIdx + 1] : undefined;
+if (byIdx >= 0 && !by) {
+  console.error("--by needs a value");
+  process.exit(2);
+}
+const positional = args.filter((a, i) => !(byIdx >= 0 && (i === byIdx || i === byIdx + 1)));
+if (positional.length !== 1 || positional[0].startsWith("--")) {
+  console.error(`expected exactly one subsystem name — run node qa/record-audit.mjs --help`);
+  process.exit(2);
+}
+
+const res = recordAudit(ROOT, { subsystem: positional[0], by });
+if (!res.ok) {
+  console.error(`refused: ${res.reason}`);
+  const pkgRoot = androidMainPackageRoot(ROOT);
+  if (pkgRoot.ok) {
+    console.error(`derived subsystems: ${listSubsystems(ROOT, pkgRoot.rel).join(", ")}`);
+  }
+  process.exit(1);
+}
+console.log(`recorded: audit of ${res.entry.subsystem} against ${res.sha.slice(0, 7)} (by ${res.entry.by}) → ${AUDITS_REL_PATH}`);
+console.log("commit the ledger with your change — the release profile's receipt reads it.");

package/template/qa/retrospective.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// The flight recorder's reader — "did this project drift from its tooling?"
+// answered mechanically, from qa/flight-recorder.jsonl alone.
+//
+//   node qa/retrospective.mjs [--json]
+//
+// The verify lane appends one journal line per run (qa/lib/flight-recorder.mjs);
+// this CLI turns those lines into the ten-second report a retrospective
+// starts from: fast vs full ratio, which steps SKIP most and why (verbatim
+// reasons, grouped), whether the device tier is ever actually reached, the
+// longest recorded stretch with no full lane, and which degraded paths fired.
+//
+// HONESTY RULES — the reader is only as good as its refusals:
+//   - it states only what the journal recorded; a missing journal is
+//     "no flight data recorded yet" and exit 0, never an error, never a
+//     fabricated baseline;
+//   - a short journal says it is short instead of letting two entries read
+//     as a trend;
+//   - it never editorializes about the developer — every line is a count or
+//     a date about lane runs, and the human draws the conclusions.
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { readFlightJournal, renderFlightReport, summarizeFlightJournal } from "./lib/flight-recorder.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const asJson = process.argv.includes("--json");
+
+const journal = readFlightJournal(ROOT);
+
+if (!journal.exists) {
+  if (asJson) console.log(JSON.stringify({ recorded: false }));
+  else console.log("no flight data recorded yet — the journal (qa/flight-recorder.jsonl) appears after the first verify-lane run");
+  process.exit(0);
+}
+if (journal.error) {
+  console.error(`qa/flight-recorder.jsonl exists but could not be read: ${journal.error}`);
+  process.exit(1);
+}
+
+const summary = summarizeFlightJournal(journal.entries);
+
+if (asJson) {
+  console.log(JSON.stringify({ recorded: true, malformed: journal.malformed, summary }, null, 2));
+} else {
+  for (const line of renderFlightReport(summary, { malformed: journal.malformed })) {
+    console.log(line);
+  }
+}
+process.exit(0);

package/template/qa/scaffold-feature.mjs

@@ -370,6 +370,9 @@ function defaultSpec() {
 
 > Generated by \`scaffold-feature.mjs\` from the \`${SOURCE_f}\` exemplar shape. Refine the clause
 > prose below for ${F}'s real behavior (ids stay fixed) before running the verify lane.
+> Platform-behavior clauses (alarms, notifications, lock screen, audio routing) cannot be
+> proven by any desktop tier — cite them from an instrumented test in
+> \`composeApp/src/androidInstrumentedTest\` (see docs/TESTING.md, "The instrumented tier").
 
 - **${F_UPPER}-01** — Given the ${F} screen opens, When ${f} are being loaded, Then a loading
   indicator is shown and no ${f} are visible.
@@ -553,6 +556,22 @@ const APP_NAV_HOST = path.join(SRC("commonMain"), "presentation/navigation/AppNa
 // up with zero hand edits — the same reason we wire nav/DI automatically.
 const PREVIEW_REGISTRY = path.join(SRC("desktopMain"), "inspector/PreviewRegistry.kt");
 
+// ARCH-14: ViewModels are registered with EXPLICIT `viewModel { … }` factories, never
+// reflection-based `viewModelOf` (it silently ignores Kotlin constructor default
+// parameter values — a compile-time wiring error becomes a runtime resolution crash).
+// The stamped registration is cloned from the EXEMPLAR's own factory line in
+// AppModule.kt (rename applied), so its get() arity always matches the cloned
+// ViewModel's constructor whatever shape the configured exemplar has. The canonical
+// single-use-case shape is the fallback when the exemplar's line isn't found.
+function explicitViewModelRegistration(appModuleContent) {
+  const exemplarFactory = new RegExp(
+    `viewModel\\s*\\{\\s*${escapeRegExp(SOURCE_F)}ViewModel\\([^)]*\\)\\s*\\}`,
+  );
+  const m = appModuleContent.match(exemplarFactory);
+  if (m) return applyRename(m[0].replace(/\s+/g, " "));
+  return `viewModel { ${F}ViewModel(get()) }`;
+}
+
 // Each step is tagged with the presets it belongs to, same mechanism as
 // FILES above: `repository` gets repo+usecase DI (+ imports) only; `screen`
 // gets viewModel DI (+ import) + nav route + import only; `feature` gets the
@@ -567,7 +586,7 @@ const ALL_INJECTION_PLANS = [
       { presets: ["feature", "screen"], apply: (c) => injectImport(c, APP_MODULE, `import ${PACKAGE}.presentation.${f}.${F}ViewModel`) },
       { presets: ["feature", "repository"], apply: (c) => injectAtAnchor(c, APP_MODULE, "di-repositories", `single<${E}Repository> { ${E}RepositoryImpl() }`) },
       { presets: ["feature", "repository"], apply: (c) => injectAtAnchor(c, APP_MODULE, "di-usecases", `factory { Get${E}sUseCase(get()) }`) },
-      { presets: ["feature", "screen"], apply: (c) => injectAtAnchor(c, APP_MODULE, "di-viewmodels", `viewModelOf(::${F}ViewModel)`) },
+      { presets: ["feature", "screen"], apply: (c) => injectAtAnchor(c, APP_MODULE, "di-viewmodels", explicitViewModelRegistration(c)) },
     ],
   },
   {