@@ -0,0 +1,28 @@
+---
+"@objectstack/cli": minor
+---
+
+fix(cli)!: `objectstack build` writes the runtime module whenever a callable still needs it, and its warning counts each refused handler once (#22853)
+
+Clause-②: no (narrowing)
+
+`objectstack build` decided whether to write `objectstack-runtime.*.mjs` from the number of callables minus the number of slots lowered into a metadata body. The first counts each callable once and the second counts each slot, so a callable lowered at two slots cancelled a `functions` entry beside it. The build then printed `Skipping legacy runtime bundle (all 2 callables are body-only)`, exited 0 and wrote `dist/objectstack.json` alone, and the `functions` entry shipped with no implementation. Three shapes reached it:
+
+- the same hook at the top level and inside a `packages[i].manifest` body, beside a `functions` entry;
+- one handler shared by two hooks, beside a `functions` entry;
+- one function bound both as a hook handler and as a `functions` entry.
+
+The module is now decided from the list `--strict-body` counts: one row per callable the runtime module has to carry, each callable once. A slot that has no body, which is a `functions` entry or a hook or action whose extraction was refused, keeps its callable on that list even when another slot lowered the same function. The default build's warning (`N handlers could not be lowered to a metadata body`) and its summary line now count the refused handlers on that list, each once.
+
+**BREAKING: what moves for consumers.**
+
+- **`objectstack build`.** It now writes the runtime module for the three shapes above, and for a function bound at a refused slot and at a slot that lowered it. Every stack it wrote the module for before still gets one.
+- **`objectstack build --no-runtime-bundle`.** Those stacks are now refused (exit 1). They passed at exit 0 while the `functions` entry, or the refused hook, had no implementation. The message's first number counts the callables that lack a body, and its second counts the refused handlers, each once.
+- **`objectstack build --strict-body`.** A stack that binds one function at a slot that lowered it AND as a `functions` entry or at a refused slot is now refused, and the row names the `functions` entry or the refused slot. It passed before. For a function bound at several slots, the row in `--json` `issues` is the extractor's refusal when any slot refused it, then the `functions` entry's row, then the authored-`body` row. Before, it was the first such slot's row.
+- **The default build's warning count.** A refused handler shared by two hooks, or carried at the top level and in a package body, counts as one handler. It counted once per slot.
+
+**The one-line fix**, for a CI step that runs `--no-runtime-bundle` on a stack carrying a `functions` entry: drop the flag. A `functions` entry has no metadata body, so it runs only from the runtime module.
+
+**Unchanged.** For a stack in which each callable is bound at one slot and walked once, the module decision, `--no-runtime-bundle` and `--strict-body` give the same verdicts as before. Exit codes and `error` strings are the same. `--json` `bodyExtractionWarnings` still carries one record per refused slot. No spec key, export, type or stored shape moves.
+
+<!-- adr-0087: not-required (no-migration-prescription) a CLI build verdict: the runtime module is now written for stacks whose `functions` entry needed it, and `--no-runtime-bundle` / `--strict-body` refuse those stacks where a miscount let them pass. No authorable key, spelling, export or stored shape moves, and no stored row is read, rewritten or converted, so there is nothing for `objectstack migrate meta` to derive. The other categories are closed on facts: the package publishes (not unpublished); no ADR-0087 id covers this verdict (not already-registered); and it is a build verdict, not a runtime TS interface or a type surface (not runtime-interface-only or type-surface-only). -->
@@ -16,7 +16,7 @@ import {
 } from '@objectstack/spec';
 import { loadConfig, namedExportRejectionHints } from '../utils/config.js';
 import { refuseUnbuiltStack } from '../utils/stack-provenance-refusal.js';
-import { lowerCallables } from '../utils/lower-callables.js';
+import { isExtractionRefusal, lowerCallables } from '../utils/lower-callables.js';
 import { authoringRuleUnionStack } from '../utils/stack-collections.js';
 import { artifactPackages, runPerPackageAuthoringRules } from '../utils/artifact-packages.js';
 import { stackFilterJudge } from '../utils/authoring-filter-judge.js';
@@ -328,6 +328,12 @@ export default class Compile extends Command {
       //     all hooks disabled.
       if (!flags.json) printStep('Lowering inline handlers...');
       const lowering = lowerCallables(normalized);
+      // The callables the extractor refused, each once: the refusal rows of the
+      // one population every verdict below reads. ⛔ Not
+      // `bodyExtractionWarnings`, which records a refusal once per SLOT — a
+      // handler shared by two hooks, or the same callable at the top level and
+      // in a `packages[i].manifest` body, is in it twice.
+      const refusedCallables = lowering.bodylessCallables.filter(isExtractionRefusal);
 
       // Strict-body gate: refuse to ship if any callable was not lowered into a
       // metadata body, i.e. if the runtime module would still have to carry it.
@@ -379,14 +385,18 @@ export default class Compile extends Command {
       //     dump for `--strict-body`'s per-callable diagnostic; on the default path
       //     we print the first line and point at the flag for the rest, so the
       //     default build stays readable while staying honest.
-      if (lowering.bodyExtractionWarnings.length > 0 && !flags.json) {
-        const n = lowering.bodyExtractionWarnings.length;
+      //
+      //     It counts and lists `refusedCallables`, each refused handler once, so
+      //     its number is the number of handlers the runtime module carries for
+      //     a refusal, not the number of slots that refused one.
+      if (refusedCallables.length > 0 && !flags.json) {
+        const n = refusedCallables.length;
         console.log('');
         printWarning(
           `${n} handler${n === 1 ? '' : 's'} could not be lowered to a metadata body — ` +
             `bundled via the legacy runtime module instead (build still succeeds)`,
         );
-        for (const w of lowering.bodyExtractionWarnings.slice(0, 20)) {
+        for (const w of refusedCallables.slice(0, 20)) {
           console.log(`  • ${w.origin}: ${String(w.reason).split('\n')[0]}`);
         }
         if (n > 20) console.log(chalk.dim(`  … and ${n - 20} more`));
@@ -1019,18 +1029,28 @@ export default class Compile extends Command {
       if (lowering.count > 0) {
         // New default: auto-skip the legacy bundle when every callable is
         // body-only (the metadata is fully self-describing). The bundle is
-        // emitted only when (a) some callable could not be lowered, or
-        // (b) the user explicitly opted in via --runtime-bundle.
-        const stillNeeded = lowering.count - lowering.bodyExtracted;
-        const needsBundle = stillNeeded > 0 || lowering.bodyExtractionWarnings.length > 0;
+        // emitted only when (a) some callable still needs it, or (b) the user
+        // explicitly opted in via --runtime-bundle.
+        //
+        // (a) is `bodylessCallables` being non-empty: the list `--strict-body`
+        // counts, one row per callable the module has to carry. ⛔ Never
+        // decide it from `count - bodyExtracted` again. `count` is per
+        // callable and `bodyExtracted` per lowered slot, so a callable lowered
+        // at two slots (a handler shared by two hooks, or the same hook at the
+        // top level and in a `packages[i].manifest` body) cancelled a
+        // `functions` entry beside it: the module was skipped and the entry
+        // shipped with no implementation, at exit 0. Every extraction refusal
+        // is a row of this list, so the warnings need no second term here.
+        const bodyless = lowering.bodylessCallables;
+        const needsBundle = bodyless.length > 0;
         const forceBundle = flags['runtime-bundle'];
         const strictNoBundle = flags['no-runtime-bundle'];
 
         if (strictNoBundle && needsBundle) {
           // Legacy strict mode: explicit --no-runtime-bundle fails loudly
           // when any callable still requires the bundle. Preserved so CI
           // pipelines can guard against accidental regressions.
-          const msg = `--no-runtime-bundle requires every callable to have a metadata body (${stillNeeded} missing, ${lowering.bodyExtractionWarnings.length} extraction warning(s)). Re-run with --strict-body to see details, or omit --no-runtime-bundle.`;
+          const msg = `--no-runtime-bundle requires every callable to have a metadata body (${bodyless.length} missing, ${refusedCallables.length} extraction warning(s)). Re-run with --strict-body to see details, or omit --no-runtime-bundle.`;
           if (flags.json) {
             await emitJson({ success: false, error: msg, warnings: warningsSoFar(), conversions: conversionNotices }, 0, { compact: true });
             this.exit(1);
@@ -1176,11 +1196,11 @@ export default class Compile extends Command {
       if (ruleAdvisories.length > 0) {
         printWarning(`${ruleAdvisories.length} author-time warning(s) — see above`);
       }
-      if (lowering.bodyExtractionWarnings.length > 0) {
+      if (refusedCallables.length > 0) {
         // [#10678] Repeat the tally in the summary: the detail printed before the
-        // parse, and a long build scrolls it away.
+        // parse, and a long build scrolls it away. Same number as that detail.
         printWarning(
-          `${lowering.bodyExtractionWarnings.length} handler(s) bundled instead of lowered to a metadata body — see above`,
+          `${refusedCallables.length} handler(s) bundled instead of lowered to a metadata body — see above`,
         );
       }
       console.log('');