fix(cli,verify,dogfood): branch the multi-org remedy on the ABSENCE, not on one failure kind (#15158)

* test(cli,verify,dogfood): pin the third failure kind's remedy at all three sites

Red-first for #14270. #14041 added a third `HostImportFailureKind`,
`declared-no-loadable-entry` — the app declares the package, the install
delivered it, and the package's own `exports` names no runtime entry Node
can load. Three consumers pick their remedy with a two-way branch written
when only two kinds existed, so the third falls into the else leg and
renders the DECLARE remedy at an operator who has already declared AND
installed it.

Each site gets a fixture carrying that kind and an assertion naming which
arm fired. The verify and dogfood fixtures are real host roots on disk
whose installed package publishes a `types`-only `exports` map; the CLI
formatter takes the kind directly. Controls for `undeclared` and
`declared-unresolvable` are untouched.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016yfqQh2dBgPAymYd7xipza

* fix(cli,verify,dogfood): branch the multi-org remedy on the ABSENCE, not on one kind

`declared-no-loadable-entry` (#14041) means the app declares the package,
the install delivered it, and the package's own `exports` names no runtime
entry Node can load. All three consumers picked their remedy with a
two-way branch written when only two kinds existed, so that kind fell into
the else leg and printed "declare it in the app's package.json and
install" — at an operator who has already done both, and directly
contradicting the importer's own message printed beside it.

Each branch now asks "is the declaration the problem?": undeclared keeps
the declare remedy, `declared-unresolvable` keeps the install remedy, and
the third kind prescribes nothing and defers to the importer's message,
which every one of the three sites already interpolates. No fourth remedy
sentence is minted — the importer words the package-shape case once, and a
local re-wording would be a second copy to drift.

`packages/types` is untouched: the strings deferred to are #14278's.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016yfqQh2dBgPAymYd7xipza

* chore(changeset): the multi-org remedy stops re-prescribing a declaration the app already has

Patch for @objectstack/cli and @objectstack/verify — the two published
packages whose `files` field ships the changed code. @objectstack/dogfood
is `private: true` with no `files`, so it publishes nothing and takes no
changeset entry.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016yfqQh2dBgPAymYd7xipza

* test(verify): keep the new cases off `@objectstack/verify`'s frozen TEST_DEBT

`harness.host-resolution.test.ts` imports `./harness` without the `.js`
extension, so under NodeNext the specifier does not resolve and every
symbol it names is `any` — which makes a `.then` callback PARAMETER
implicitly any. The two new cases used `.then(onFulfilled, onRejected)`
and added 2 x TS7006, taking the package's TEST_DEBT entry from its
recorded 3 to 5. That ledger is shrink-only, so the fix is the errors,
not the ceiling.

try/catch instead: a `const` initialised from an `any` call is not a
diagnostic, only a parameter is. `check:type-check-debt --re-measure`
now reports 17 entries re-measured, 217 raw errors, none above its
recorded number.

⛔ Deliberately NOT the one-line `.js` fix that graduates the entry — that
is a different card's, filed separately.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016yfqQh2dBgPAymYd7xipza

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: os-trump

.changeset/multi-org-remedy-third-failure-kind.md

@@ -0,0 +1,33 @@
+---
+"@objectstack/cli": patch
+"@objectstack/verify": patch
+---
+
+fix(cli,verify): the multi-org runtime's remedy stops telling an operator to declare a package the app already declares
+
+The three consumers that turn a failed `@objectstack/organizations` import into
+operator-facing advice picked their remedy with a two-way branch, written when
+`HostImportFailureKind` had exactly two members. A third one — a package the app
+DECLARES, that the install DELIVERED, and whose own `exports` names no runtime
+entry Node can load (a `types`-only or `browser`-only publish, or an unexported
+subpath) — fell into the else leg and rendered the *declare* remedy:
+
+- `objectstack serve`'s ADR-0093 D5 stage-1 fatal ("add the package to THIS APP
+  — declare it in the app's package.json and install"),
+- `bootStack({ multiTenant: true })`'s refusal ("Install/link it in THIS APP —
+  and DECLARE it in that app's package.json"),
+- the enterprise dogfood probe's skip reason and its `MULTI_ORG=1` throw.
+
+Each of those three also prints the importer's own message, which words the case
+correctly — so the bullet an operator reads first contradicted the diagnosis
+printed underneath it, and prescribed two actions (declare it, install it) that
+were already done and could not have helped: no edit to the app and no install
+action changes what a package publishes.
+
+Every branch now asks *is the declaration the problem?* rather than testing one
+kind. `undeclared` keeps the declare remedy and `declared-unresolvable` keeps
+the install remedy, both byte-for-byte unchanged. The third kind prescribes
+nothing: it names the two things that are NOT the problem and defers to the
+importer's message, which already states that the remedy lives in the package
+and what the package has to publish. No fourth remedy sentence is minted — one
+wording of the package-shape case, in the one place that measured it.

packages/cli/src/commands/serve-organizations-message-spelling.test.ts

@@ -137,6 +137,8 @@ const UNDECLARED: HostDeclaration = { packageName: PKG, hostRoot: '/srv/app', de
 
 const remedyDeclared = () => formatOrganizationsInstallRemedy('declared-unresolvable', DECLARED, '/srv/app');
 const remedyUndeclared = () => formatOrganizationsInstallRemedy('undeclared', UNDECLARED, '/srv/app');
+const remedyNoLoadableEntry = () =>
+  formatOrganizationsInstallRemedy('declared-no-loadable-entry', DECLARED, '/srv/app');
 
 describe('serve — the multi-org runtime name an operator READS comes from the declaration (#12151)', () => {
   it('site 1 — the "install is broken" remedy names it, with the spacing intact', () => {
@@ -154,6 +156,40 @@ describe('serve — the multi-org runtime name an operator READS comes from the
     );
   });
 
+  it('site 2b — the `declared-no-loadable-entry` remedy DEFERS, it does not re-prescribe (#14270)', () => {
+    // ── The arm that used to fire, quoted so the flip is legible ──────────
+    // This formatter was a TWO-WAY branch written when only two kinds existed
+    // (`declared-unresolvable` vs everything else). #14041 added a third —
+    // the app DECLARES the package, the install DELIVERED it, and the
+    // package's own `exports` names no runtime entry Node can load — and it
+    // fell into the else leg, rendering the UNDECLARED remedy verbatim:
+    //
+    //       • add @objectstack/organizations (the enterprise multi-org runtime) to THIS APP
+    //         — declare it in the app's package.json and install; the CLI resolves it from the
+    //
+    // i.e. "declare it and install it" to an operator who has already done
+    // both. That superseded wording is what site 2 above still pins for the
+    // kind it is actually right for; here it is the confidently-wrong verdict
+    // #14041 exists to remove, one layer up.
+    expect(lines(remedyNoLoadableEntry())[0]).toBe(
+      `      • this app DECLARES ${PKG} (dependencies: "^1.2.3") and it IS`,
+    );
+
+    const rendered = plain(remedyNoLoadableEntry());
+    // ⛔ NEITHER of the other two arms' instructions may appear. Both are
+    // unfollowable for this kind, and each contradicts the importer's own
+    // message, which is printed as the `cause:` line of the same refusal.
+    expect(rendered).not.toContain("declare it in the app's package.json");
+    expect(rendered).not.toContain('Repair the INSTALL');
+    // What it says instead: where the remedy lives, and that the importer's
+    // message below is the authority on it — a DEFERRAL, deliberately not a
+    // fourth remedy sentence minted here (and in two other consumers).
+    expect(rendered).toContain('publishes no entry Node can load');
+    expect(rendered).toContain('the cause below is the authority');
+    // It still chains into the `Fix one of:` list the fatal assembles.
+    expect(rendered.endsWith(' — or\n')).toBe(true);
+  });
+
   it('site 3 — the ADR-0093 D5 fatal refusal names it', () => {
     const fatal = formatOrganizationsAbsentFatal('isolated', remedyUndeclared(), 'Cannot find package');
     // A leading blank line separates the refusal from whatever boot last printed.
@@ -188,6 +224,7 @@ describe('serve — the multi-org runtime name an operator READS comes from the
     for (const [label, rendered] of [
       ['remedy (declared)', remedyDeclared()],
       ['remedy (undeclared)', remedyUndeclared()],
+      ['remedy (no loadable entry)', remedyNoLoadableEntry()],
       ['stage-1 fatal', formatOrganizationsAbsentFatal('group', remedyUndeclared(), 'ERR_MODULE_NOT_FOUND')],
       ['degraded warning', formatDegradedTenancyWarning('group')],
       ['stage-2 fatal', formatOrganizationsMountFatal('group', 'refused', undefined)],

packages/cli/src/commands/serve.ts

@@ -5225,34 +5225,69 @@ export function formatI18nLoadDiagnostic(pkg: string, err: unknown): string {
  */
 
 /**
- * The install remedy bullet for a multi-org runtime that would not load — two
- * absences, two remedies (#4719).
- *
- * `declared-unresolvable` means the app's `package.json` DOES name the package
- * and the install is what is broken; anything else means the app never declared
- * it. Telling the first operator to re-read a file that is already correct is
- * the defect this branch exists to avoid.
+ * The install remedy bullet for a multi-org runtime that would not load — one
+ * bullet per ABSENCE, and the absences are what the branch reads (#4719).
+ *
+ * ## What the branch is ON, and why it is not a kind list
+ *
+ * The question each arm answers is **"is the declaration the problem?"**:
+ *
+ *   - `declared-unresolvable` — the app's `package.json` DOES name the package
+ *     and the INSTALL is what is broken. Telling that operator to re-read a
+ *     file that is already correct is the defect this branch exists to avoid.
+ *   - `declared-no-loadable-entry` (#14041) — the app declares it, the install
+ *     DELIVERED it, and the package's own `exports` names no runtime entry
+ *     Node can load. Neither absence applies: there is nothing to declare and
+ *     nothing to install, so this arm prescribes NOTHING and defers to the
+ *     importer's own message, which `formatOrganizationsAbsentFatal` prints
+ *     verbatim as the `cause:` line of the same refusal (#14270).
+ *   - anything else — the app never declared it, so the declare-and-install
+ *     remedy is the one that works.
+ *
+ * ⚠️ This was a TWO-WAY branch written when only two kinds existed, so the
+ * third fell into the else leg and told an operator whose app already declares
+ * AND installs the package to declare and install it — the
+ * confidently-wrong-verdict class #14041 removed one layer down, reintroduced
+ * by its consumer. ⛔ The third arm deliberately does NOT mint a fourth remedy
+ * sentence: the importer already words the package-shape case, and a local
+ * re-wording here would be a second copy to drift (the same reason
+ * {@link formatI18nLoadDiagnostic} interpolates only the kind TOKEN, and the
+ * same shape as {@link formatOrganizationsMountFatal}'s "its message is the
+ * authority on the remedy").
+ *
+ * An error carrying NO kind never came from the host importer at all and keeps
+ * the declare-and-install arm it has always had — narrowing that one is a
+ * different question, about a different fact, and is not this branch's.
  */
 export function formatOrganizationsInstallRemedy(
   kind: HostImportFailureKind | undefined,
   declaration: HostDeclaration,
   hostRoot: string,
 ): string {
   const pkg = Serve.ORGANIZATIONS_RUNTIME_PKG;
-  return kind === 'declared-unresolvable'
-    ? `      • this app DECLARES ${pkg} ` +
+  if (kind === 'declared-unresolvable') {
+    return `      • this app DECLARES ${pkg} ` +
       `(${declaration.field}: ${JSON.stringify(declaration.specifier)}) — the\n` +
       '        declaration is NOT the problem and re-reading package.json will not help.\n' +
       `        Repair the INSTALL in ${hostRoot}: run \`pnpm install\`, check that a\n` +
-      '        production prune did not drop it, and that its dist is actually built — or\n'
-    : `      • add ${pkg} (the enterprise multi-org runtime) to THIS APP\n` +
-      "        — declare it in the app's package.json and install; the CLI resolves it from the\n" +
-      '          app, not from the framework it is linked out of. Being merely reachable\n' +
-      '          through NODE_PATH / a hoisted workspace store is deliberately not enough\n' +
-      '          (#4719) — that made this wall depend on how the process was launched.\n' +
-      '          NOTE: this runtime is closed-source and is NOT on the public npm registry —\n' +
-      '          it is distributed with an enterprise / cloud subscription. Without one this\n' +
-      '          bullet is not followable, and one of the two below is your path — or\n';
+      '        production prune did not drop it, and that its dist is actually built — or\n';
+  }
+  if (kind === 'declared-no-loadable-entry') {
+    return `      • this app DECLARES ${pkg} ` +
+      `(${declaration.field}: ${JSON.stringify(declaration.specifier)}) and it IS\n` +
+      '        INSTALLED — neither the declaration nor the install is the problem, and no change\n' +
+      '        you make in this app can fix it. The package publishes no entry Node can load;\n' +
+      '        the remedy is in the package, and the cause below is the authority on what it\n' +
+      '        has to publish — or\n';
+  }
+  return `      • add ${pkg} (the enterprise multi-org runtime) to THIS APP\n` +
+    "        — declare it in the app's package.json and install; the CLI resolves it from the\n" +
+    '          app, not from the framework it is linked out of. Being merely reachable\n' +
+    '          through NODE_PATH / a hoisted workspace store is deliberately not enough\n' +
+    '          (#4719) — that made this wall depend on how the process was launched.\n' +
+    '          NOTE: this runtime is closed-source and is NOT on the public npm registry —\n' +
+    '          it is distributed with an enterprise / cloud subscription. Without one this\n' +
+    '          bullet is not followable, and one of the two below is your path — or\n';
 }
 
 /**

packages/qa/dogfood/test/enterprise-organizations.test.ts

@@ -29,11 +29,23 @@ let hostWithoutPkg: string;
  * resolver, and it used to read as AVAILABLE.
  */
 let hostInstalledButUndeclared: string;
+/**
+ * #14041/#14270 — declared AND installed, and the package's own `exports` names
+ * no runtime entry Node can load (a `types`-only publish). The third
+ * `HostImportFailureKind`; no install action can change what a package
+ * publishes, so the "declare it and install it" remedy is unfollowable here.
+ */
+let hostDeclaredNoLoadableEntry: string;
+/**
+ * The `declared-unresolvable` CONTROL: declared and NOT installed. #14270 left
+ * this arm alone, so its wording must come out byte-identical.
+ */
+let hostDeclaredNotInstalled: string;
 
 function writeHost(
   prefix: string,
   withPkg: boolean,
-  opts: { declare?: boolean } = {},
+  opts: { declare?: boolean; typesOnly?: boolean } = {},
 ): string {
   const declare = opts.declare ?? withPkg;
   const dir = mkdtempSync(join(tmpdir(), prefix));
@@ -50,6 +62,27 @@ function writeHost(
   if (withPkg) {
     const pkgDir = join(dir, 'node_modules', ...ORGANIZATIONS_PKG.split('/'));
     mkdirSync(pkgDir, { recursive: true });
+    if (opts.typesOnly) {
+      // No `require` condition (the CJS resolver throws) and no `import`
+      // condition (the #14041 fallback finder has nothing to load) — the
+      // manifest names nothing runnable at all.
+      writeFileSync(
+        join(pkgDir, 'package.json'),
+        JSON.stringify({
+          name: ORGANIZATIONS_PKG,
+          version: '0.0.0-fixture',
+          type: 'module',
+          exports: { '.': { types: './index.d.ts' } },
+        }),
+        'utf8',
+      );
+      writeFileSync(
+        join(pkgDir, 'index.d.ts'),
+        'export declare class OrganizationsPlugin {}\n',
+        'utf8',
+      );
+      return dir;
+    }
     writeFileSync(
       join(pkgDir, 'package.json'),
       JSON.stringify({
@@ -73,10 +106,18 @@ beforeAll(() => {
   hostWithPkg = writeHost('os-dogfood-org-ok-', true);
   hostWithoutPkg = writeHost('os-dogfood-org-missing-', false);
   hostInstalledButUndeclared = writeHost('os-dogfood-org-undeclared-', true, { declare: false });
+  hostDeclaredNoLoadableEntry = writeHost('os-dogfood-org-no-entry-', true, { typesOnly: true });
+  hostDeclaredNotInstalled = writeHost('os-dogfood-org-not-installed-', false, { declare: true });
 });
 
 afterAll(() => {
-  for (const dir of [hostWithPkg, hostWithoutPkg, hostInstalledButUndeclared]) {
+  for (const dir of [
+    hostWithPkg,
+    hostWithoutPkg,
+    hostInstalledButUndeclared,
+    hostDeclaredNoLoadableEntry,
+    hostDeclaredNotInstalled,
+  ]) {
     if (dir) rmSync(dir, { recursive: true, force: true });
   }
 });
@@ -132,4 +173,46 @@ describe('enterprise multi-org probe (#4700)', () => {
       new RegExp(`declare ${ORGANIZATIONS_PKG.replace('/', '\\/')} in .* package\\.json`),
     );
   });
+
+  it('CONTROL — the `declared-unresolvable` remedy is unchanged: declared, not installed', async () => {
+    // The arm #14270 did NOT touch. Pinned here so the three-way rewrite is a
+    // measurement: this text has to be byte-identical either side of it.
+    const probe = await probeOrganizations(hostDeclaredNotInstalled, false);
+    expect(probe.available).toBe(false);
+    expect(probe.reason).toContain(
+      `${hostDeclaredNotInstalled} DECLARES ${ORGANIZATIONS_PKG}, so repair its INSTALL there `
+      + '(`pnpm install`, un-prune, rebuild its dist)',
+    );
+  });
+
+  it('DEFERS to the importer when the package is declared, installed, and unloadable (#14270)', async () => {
+    // #14041's third kind. This probe's remedy was a two-way branch written for
+    // two, so `declared-no-loadable-entry` fell into the else leg and told an
+    // operator whose app DECLARES the package and HAS it installed to declare
+    // it and install it. No install action can change what a package publishes.
+    const probe = await probeOrganizations(hostDeclaredNoLoadableEntry, false);
+    expect(probe.available).toBe(false);
+    // Which arm fired: the deferral names the two things that are NOT the
+    // problem and hands the remedy to the importer's message, which this
+    // reason interpolates at the end.
+    expect(probe.reason).toContain('and it IS installed, so neither is the problem');
+    expect(probe.reason).toContain('publishes no entry Node can load');
+    // ⛔ Neither of the other two arms — both are unfollowable for this kind.
+    expect(probe.reason).not.toContain(`declare ${ORGANIZATIONS_PKG} in`);
+    expect(probe.reason).not.toContain('repair its INSTALL');
+    // The message deferred TO has to actually arrive.
+    expect(probe.reason).toContain('publishes no entry that Node can load');
+  });
+
+  it('THROWS with that same deferral when the run declares the package (#14270)', async () => {
+    // The loud half: MULTI_ORG=1 says the package is there, and it IS — it just
+    // cannot be loaded. The refusal must still name the right remedy.
+    const err = await probeOrganizations(hostDeclaredNoLoadableEntry, true).then(
+      () => new Error('probeOrganizations resolved; MULTI_ORG=1 must make this a failure'),
+      (e: unknown) => e as Error,
+    );
+    expect(err.message).toContain(MULTI_ORG_ENV);
+    expect(err.message).toContain('and it IS installed, so neither is the problem');
+    expect(err.message).not.toContain(`declare ${ORGANIZATIONS_PKG} in`);
+  });
 });

packages/qa/dogfood/test/enterprise-organizations.ts

@@ -114,13 +114,23 @@ export async function probeOrganizations(
     const detail = (e as Error).message;
     // #4719 — name the remedy that actually applies. "Install it" is useless
     // advice for an app that installed it and never declared it, which is the
-    // shape a workspace makes easy and a hoisted store used to hide.
+    // shape a workspace makes easy and a hoisted store used to hide. #14270 —
+    // the branch reads "is the declaration the problem?", so #14041's third
+    // kind (declared, installed, and the package publishes nothing loadable)
+    // gets neither instruction: no install action can change what a package
+    // publishes, so this arm defers to the importer's own message, which
+    // `detail` interpolates at the end of both strings below.
+    const kind = hostImportFailureKind(e);
     const remedy =
-      hostImportFailureKind(e) === 'declared-unresolvable'
+      kind === 'declared-unresolvable'
         ? `${root} DECLARES ${ORGANIZATIONS_PKG}, so repair its INSTALL there (\`pnpm install\`, ` +
           'un-prune, rebuild its dist)'
-        : `declare ${ORGANIZATIONS_PKG} in ${root}'s own package.json and install it — being ` +
-          'reachable as somebody else\'s transitive dependency is not enough (#4719)';
+        : kind === 'declared-no-loadable-entry'
+          ? `${root} DECLARES ${ORGANIZATIONS_PKG} and it IS installed, so neither is the ` +
+            'problem — the package publishes no entry Node can load, and the importer\'s ' +
+            'message below is the authority on what it has to publish'
+          : `declare ${ORGANIZATIONS_PKG} in ${root}'s own package.json and install it — being ` +
+            'reachable as somebody else\'s transitive dependency is not enough (#4719)';
     if (declared) {
       throw new Error(
         `${MULTI_ORG_ENV}=1 declares that ${ORGANIZATIONS_PKG} (enterprise, ADR-0105 D12) is ` +