fallow 3.4.2 → 3.5.1

package/README.md

@@ -2,98 +2,60 @@
 
 **Codebase intelligence for TypeScript and JavaScript.**
 
-Free static analysis of code and styles, optional paid runtime intelligence (Fallow Runtime). Quality, risk, architecture, dependencies, duplication, and design-system drift, for humans, CI, and the agents writing your code.
+One binary finds unused code, circular dependencies, duplication, complexity hotspots, boundary violations, and design-system styling drift. An optional paid layer, Fallow Runtime, adds production execution evidence. No AI inside the analyzer, and no TypeScript compiler or Node.js runtime needed for static analysis: runs are deterministic, with typed output contracts and traceable explanations.
 
 [![CI](https://github.com/fallow-rs/fallow/actions/workflows/ci.yml/badge.svg)](https://github.com/fallow-rs/fallow/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/fallow.svg)](https://www.npmjs.com/package/fallow)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/fallow-rs/fallow/blob/main/LICENSE)
 
-Fallow turns a frontend repository into a trusted quality report: health score, changed-code risk, hotspots, duplication, architecture issues, dependency hygiene, styling consistency, and cleanup opportunities.
-
-It helps you answer: what changed, what got riskier, what should be reviewed, what should be refactored, and what can be safely removed. No AI inside the analyzer. Fallow produces deterministic findings, typed output contracts, and traceable explanations that downstream tools can trust.
-
-Static analysis is open source. An optional runtime layer adds production execution evidence. Rust-native, sub-second, 123 framework plugins, no Node.js runtime dependency for analysis. fallow's edge is doing more in one pass: dead code, duplication, dependencies, complexity, architecture, styling consistency, and security candidates in a single tool. For head-to-head timings against [knip](https://knip.dev) and [jscpd](https://github.com/kucherenko/jscpd), see the [benchmarks](https://github.com/fallow-rs/fallow/tree/main/benchmarks): fallow is faster than knip on smaller projects, knip is faster on several larger repos, and jscpd's Rust rewrite is faster for raw duplication scanning.
-
-## Installation
+## Install
 
 ```bash
-npm install --save-dev fallow   # or: pnpm add -D fallow / yarn add -D fallow / bun add -d fallow
+npm install --save-dev fallow   # or: pnpm add -D fallow / yarn add -D fallow
 ```
 
-Installs the `fallow` CLI plus the companion `fallow-lsp` and `fallow-mcp` binaries in your project.
-
-The package also ships a version-matched Agent Skill under `skills/fallow`.
-For tools that need CLI and issue-surface metadata without spawning the binary,
-`fallow/capabilities.json` mirrors `fallow schema` for the installed version.
-TanStack Intent discovers it from `node_modules` automatically:
-
-```bash
-npx @tanstack/intent list
-npx @tanstack/intent load fallow#fallow
-```
-
-For one-off CLI use without project-local skill discovery, run `npx fallow`.
-
-Parsing fallow's JSON output in TypeScript? Import the typed shapes:
-
-```ts
-import type { CheckOutput, FallowJsonOutput } from "fallow/types";
-```
-
-The types are generated from the same schema as the VS Code extension and pin to the CLI version you install. See [docs.fallow.tools](https://docs.fallow.tools) for the full output contract.
+This installs the `fallow` CLI plus the `fallow-lsp` and `fallow-mcp` launchers, so editor and agent integrations resolve the project-local binary instead of whatever happens to be on `PATH`. For one-off use, run `npx fallow` without installing. Other channels (cargo, Docker, prebuilt binaries) are covered in the [installation guide](https://docs.fallow.tools/installation).
 
 ## Quick start
 
 ```bash
-npx fallow audit                 # PR-style audit: verdict pass / warn / fail
-npx fallow audit --format json   # Machine-readable audit (for CI and agents)
-npx fallow health --score        # Quality score and grade
-npx fallow                       # Full codebase analysis: health + duplication + cleanup
-npx fallow dead-code             # Cleanup-specific findings
+npx fallow                       # Full pipeline: dead code + duplication + health
+npx fallow audit                 # Gate only what a PR changed: verdict pass/warn/fail
+npx fallow health --score        # 0 to 100 health score with a letter grade
+npx fallow dupes                 # Duplication; modes strict, mild (default), weak, semantic
 npx fallow fix --dry-run         # Preview automatic cleanup
 ```
 
-## What Fallow reports
-
-- **Quality score** -- compact health score with grade and trend delta when snapshot history is enabled
-- **PR risk** -- changed-code analysis with pass / warn / fail verdict and per-finding attribution
-- **Hotspots** -- functions, files, and packages combining complexity, churn, size, and coupling
-- **Duplication** -- clone families across four detection modes (strict, mild, weak, semantic)
-- **Design-system styling** -- CSS, Sass/Less, CSS Modules, Tailwind/shadcn/CVA, StyleX/PandaCSS, vanilla-extract, styled-components, and Emotion consistency signals
-- **Architecture** -- circular dependencies, boundary violations, re-export chains
-- **Dependency hygiene** -- unused, unlisted, unresolved, duplicate, and type-only deps; pnpm catalog and overrides
-- **Cleanup opportunities** -- unused files, exports, types, enum members, class members, stale suppressions
-- **Runtime intelligence (optional)** -- hot paths, cold code, runtime-weighted health, stale flags
+## Output and exit codes
 
-Cleanup opportunities are findings that look safe to review for removal because no graph evidence supports keeping them. Dead code is one category of cleanup, not the product identity.
+Add `--format json --quiet` to any command for one typed JSON document on stdout. Exit code 1 means findings, not failure; 0 is clean (or an audit pass or warn verdict); 2 is a validation or runtime error, reported as a JSON error envelope rather than a stack trace.
 
-## Code duplication
+Parsing the output in TypeScript? Import the typed shapes, version-pinned to the CLI you install:
 
-```bash
-fallow dupes                       # Default: mild mode
-fallow dupes --mode semantic       # Catch clones with renamed variables
-fallow dupes --threshold 5         # Fail CI if duplication exceeds 5%
-fallow dupes --save-baseline       # Save current duplication as baseline
+```ts
+import type { CheckOutput, FallowJsonOutput } from "fallow/types";
 ```
 
-Four detection modes (strict, mild, weak, semantic), clone family grouping with refactoring suggestions, baseline tracking, and cross-language TS/JS matching.
+Every issue carries an `actions[]` array with an `auto_fixable` flag, so scripts and agents know which findings they can hand to `fallow fix`. The full contract lives at [docs.fallow.tools](https://docs.fallow.tools).
 
-## Built for agents
+## What fallow reports
 
-Fallow gives AI agents structured repo truth instead of forcing them to infer everything from grep. Agents call the CLI or the MCP server to answer:
+- Unused files, exports, types, enum and class members, and dependencies
+- Circular dependencies and re-export cycles
+- Code duplication as clone families, across four detection modes
+- Complexity hotspots and a 0 to 100 health score
+- Architecture boundary violations, with zero-config presets
+- Design-system styling drift for CSS and CSS-in-JS (Sass/Less, CSS Modules, Tailwind, styled-components, Emotion, and more)
+- A changed-file PR gate with per-finding attribution (`fallow audit`)
+- Optional runtime intelligence: hot paths, cold code, runtime-weighted health, stale flags (licensed Fallow Runtime; a single local coverage capture is free)
 
-- Who imports this symbol?
-- Why is this export considered used or unused?
-- What changed in this PR?
-- Which files are risky to touch?
-- What duplicate siblings exist?
-- What cleanup action is safest?
+For head-to-head timings against [knip](https://knip.dev) and [jscpd](https://github.com/kucherenko/jscpd), see [BENCHMARKS.md](https://github.com/fallow-rs/fallow/blob/main/BENCHMARKS.md): fallow is faster than knip on smaller projects, knip is faster on several larger repos, and jscpd's Rust rewrite is faster at raw duplication scanning.
 
-Every issue in `--format json` carries a machine-actionable `actions` array with an `auto_fixable` flag so agents can self-correct.
+## Built for agents
 
-### MCP server
+Agents get structured repo truth instead of inferring everything from grep: who imports a symbol, why an export counts as used, what a PR changed, which cleanup action is safest.
 
-Agents that speak MCP can launch the bundled `fallow-mcp` server. Installed as a devDependency, the binary lives in `node_modules/.bin/` and is not on your `PATH`, so launch it through your package manager's runner:
+The bundled `fallow-mcp` server lives in `node_modules/.bin/` when installed as a devDependency, so launch it through your package manager's runner:
 
 ```json
 {
@@ -106,15 +68,22 @@ Agents that speak MCP can launch the bundled `fallow-mcp` server. Installed as a
 }
 ```
 
-Swap `npx` for `pnpm exec` / `yarn` / `bunx` to match your package manager. If `fallow-mcp` is installed globally (on your `PATH`), `"command": "fallow-mcp"` works directly. See the [MCP integration guide](https://docs.fallow.tools/integrations/mcp).
+Swap `npx` for `pnpm exec` or `yarn` to match your package manager; a globally installed `fallow-mcp` works as `"command": "fallow-mcp"` directly. See the [MCP integration guide](https://docs.fallow.tools/integrations/mcp).
+
+The package also ships a version-matched agent skill under `skills/fallow`, and `fallow/capabilities.json` mirrors `fallow schema` for tools that need CLI and issue-surface metadata without spawning the binary. TanStack Intent discovers both from `node_modules`:
+
+```bash
+npx @tanstack/intent list
+npx @tanstack/intent load fallow#fallow
+```
 
 ## Framework support
 
-123 built-in plugins covering Next.js, Nuxt, Remix, Qwik, SvelteKit, Gatsby, Astro, Angular, NestJS, AdonisJS, Ember, Expo Router, Vite, Webpack, Vitest, Jest, Playwright, Cypress, Storybook, ESLint, TypeScript, Tailwind, UnoCSS, Prisma, Drizzle, Convex, Turborepo, Hardhat, and many more. Auto-detected from your `package.json`.
+Over 100 built-in framework plugins covering Next.js, Nuxt, Remix, Qwik, SvelteKit, Gatsby, Astro, Angular, NestJS, AdonisJS, Ember, Expo Router, Vite, Webpack, Vitest, Jest, Playwright, Cypress, Storybook, ESLint, TypeScript, Tailwind, UnoCSS, Prisma, Drizzle, Convex, Turborepo, Hardhat, and more. Entry points are auto-detected from `package.json`, so the first run needs no configuration.
 
 ## Configuration
 
-Create a config file in your project root, or run `fallow init`:
+Works out of the box. To customize, let [`fallow recommend`](https://docs.fallow.tools/cli/recommend) propose a config from the detected stack (read-only; `--format json` returns the full decision set for agents), run `fallow init`, or create a config file in your project root:
 
 ```jsonc
 // .fallowrc.json
@@ -130,23 +99,13 @@ Create a config file in your project root, or run `fallow init`:
 }
 ```
 
-`$schema` gives editors autocomplete and validation and has no effect on
-analysis. As an npm package, `fallow` always ships a version-aligned schema at
-`./node_modules/fallow/schema.json`, which `fallow init` and
-`fallow recommend` point at by default: offline, no editor trust prompt. If
-you install fallow another way (cargo, homebrew, a bare binary) with no
-`node_modules/fallow` to point at, use the remote fallback instead:
-`https://raw.githubusercontent.com/fallow-rs/fallow/main/schema.json`. Some
-editors, including VS Code, refuse to load a remote schema URL until you
-explicitly trust the domain.
-
-Also supports TOML (`fallow init --toml` creates `fallow.toml`).
+`$schema` gives editors autocomplete and validation and has no effect on analysis. The npm package ships a version-aligned schema at `./node_modules/fallow/schema.json`, so validation works offline with no editor trust prompt. TOML works too: `fallow init --toml` creates `fallow.toml`. Full reference: [configuration overview](https://docs.fallow.tools/configuration/overview).
 
 ## Documentation
 
-- [Full documentation](https://docs.fallow.tools)
+- [docs.fallow.tools](https://docs.fallow.tools)
 - [GitHub repository](https://github.com/fallow-rs/fallow)
-- [Plugin Authoring Guide](https://github.com/fallow-rs/fallow/blob/main/docs/plugin-authoring.md)
+- [Plugin authoring guide](https://github.com/fallow-rs/fallow/blob/main/docs/plugin-authoring.md)
 
 ## License
 

package/bin/fallow-lsp

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
 
+// Launcher shim: the platform packages ship a single multicall `fallow`
+// binary, so `fallow-lsp` spawns `fallow lsp-server` with the same stdio,
+// signal, and exit-code forwarding as a bare `fallow` invocation.
 const { runBinary } = require('../scripts/run-binary');
-runBinary('fallow-lsp');
+runBinary('fallow', { prependArgs: ['lsp-server'] });

package/bin/fallow-mcp

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
 
+// Launcher shim: the platform packages ship a single multicall `fallow`
+// binary, so `fallow-mcp` spawns `fallow mcp-server` with the same stdio,
+// signal, and exit-code forwarding as a bare `fallow` invocation.
 const { runBinary } = require('../scripts/run-binary');
-runBinary('fallow-mcp');
+runBinary('fallow', { prependArgs: ['mcp-server'] });

package/capabilities.json

@@ -1,6 +1,6 @@
 {
   "name": "fallow",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "manifest_version": "1",
   "description": "Codebase analyzer for TypeScript/JavaScript: unused code, circular dependencies, code duplication, complexity hotspots, and architecture boundary violations",
   "global_flags": [
@@ -311,7 +311,7 @@
       "name": "--save-regression-baseline",
       "type": "string",
       "required": false,
-      "description": "Save the current issue counts as a regression baseline"
+      "description": "Save the current issue counts as a regression baseline. Omit PATH to update regression.baseline in the discovered fallow config, or create .fallowrc.json when none exists. Provide PATH to write a standalone file"
     },
     {
       "name": "--only",
@@ -854,6 +854,16 @@
             "true",
             "false"
           ]
+        },
+        {
+          "name": "--churn",
+          "type": "bool",
+          "required": false,
+          "description": "OPT-IN: attach target-level git churn evidence from the health hotspot subsystem. Default off to avoid git-history latency",
+          "possible_values": [
+            "true",
+            "false"
+          ]
         }
       ]
     },
@@ -6380,7 +6390,8 @@
         "cli_command": "fallow inspect --format json --quiet",
         "key_params": [
           "target",
-          "production"
+          "production",
+          "include_churn"
         ],
         "license": "free",
         "license_note": null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fallow",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "description": "Codebase intelligence for TypeScript and JavaScript. Free static analysis of code and styles, optional paid runtime intelligence (Fallow Runtime). Quality, risk, architecture, dependencies, duplication, and design-system drift for humans, CI, and the agents writing your code. Zero-config framework support.",
   "license": "MIT",
   "repository": {
@@ -84,16 +84,16 @@
     "detect-libc": "2.1.2"
   },
   "devDependencies": {
-    "@tanstack/intent": "0.3.2"
+    "@tanstack/intent": "0.3.5"
   },
   "optionalDependencies": {
-    "@fallow-cli/darwin-arm64": "3.4.2",
-    "@fallow-cli/darwin-x64": "3.4.2",
-    "@fallow-cli/linux-x64-gnu": "3.4.2",
-    "@fallow-cli/linux-arm64-gnu": "3.4.2",
-    "@fallow-cli/linux-x64-musl": "3.4.2",
-    "@fallow-cli/linux-arm64-musl": "3.4.2",
-    "@fallow-cli/win32-arm64-msvc": "3.4.2",
-    "@fallow-cli/win32-x64-msvc": "3.4.2"
+    "@fallow-cli/darwin-arm64": "3.5.1",
+    "@fallow-cli/darwin-x64": "3.5.1",
+    "@fallow-cli/linux-x64-gnu": "3.5.1",
+    "@fallow-cli/linux-arm64-gnu": "3.5.1",
+    "@fallow-cli/linux-x64-musl": "3.5.1",
+    "@fallow-cli/linux-arm64-musl": "3.5.1",
+    "@fallow-cli/win32-arm64-msvc": "3.5.1",
+    "@fallow-cli/win32-x64-msvc": "3.5.1"
   }
 }

package/scripts/lazy-verify.js

@@ -66,8 +66,11 @@ function emitVerifyLog(env, payload) {
 }
 
 function binaryTargetsForPlatform(platform) {
+  // Platform packages ship one binary: the multicall `fallow`. The bundled
+  // lsp/mcp launchers spawn `fallow lsp-server` / `fallow mcp-server`, so there
+  // is only one binary to sentinel-track and verify.
   const ext = platform === "win32" ? ".exe" : "";
-  return [`fallow${ext}`, `fallow-lsp${ext}`, `fallow-mcp${ext}`];
+  return [`fallow${ext}`];
 }
 
 function statMtimeMs(absPath) {

package/scripts/lazy-verify.test.js

@@ -28,7 +28,8 @@ function ext() {
 }
 
 function binaryNames() {
-  return [`fallow${ext()}`, `fallow-lsp${ext()}`, `fallow-mcp${ext()}`];
+  // Platform packages ship a single multicall `fallow` binary.
+  return [`fallow${ext()}`];
 }
 
 function computeDigestsForDir(dir) {
@@ -116,7 +117,7 @@ test("ensureVerified verifies on cache miss and writes the sentinel", (t) => {
   assert.equal(sentinel.schemaVersion, SENTINEL_SCHEMA_VERSION);
   assert.equal(sentinel.packageVersion, "2.81.0");
   assert.equal(sentinel.packageName, "@fallow-cli/test-platform");
-  assert.equal(Object.keys(sentinel.binaries).length, 3);
+  assert.equal(Object.keys(sentinel.binaries).length, 1);
 });
 
 test("ensureVerified returns cached:true on a valid sentinel", (t) => {
@@ -164,7 +165,7 @@ test("ensureVerified invalidates sentinel on mtime drift", (t) => {
   );
   assert.equal(result.ok, true);
   assert.equal(result.cached, false);
-  assert.equal(verifyCallCount, 3, "verify should rerun for all three binaries");
+  assert.equal(verifyCallCount, 1, "verify should rerun for the single binary");
 });
 
 test("ensureVerified invalidates sentinel on packageVersion drift", (t) => {
@@ -215,12 +216,6 @@ test("ensureVerified invalidates sentinel on packageName drift", (t) => {
       packageName: "@fallow-cli/wrong-name",
       binaries: {
         [`fallow${ext()}`]: { mtimeMs: fs.statSync(path.join(dir, `fallow${ext()}`)).mtimeMs },
-        [`fallow-lsp${ext()}`]: {
-          mtimeMs: fs.statSync(path.join(dir, `fallow-lsp${ext()}`)).mtimeMs,
-        },
-        [`fallow-mcp${ext()}`]: {
-          mtimeMs: fs.statSync(path.join(dir, `fallow-mcp${ext()}`)).mtimeMs,
-        },
       },
     }),
   );
@@ -266,13 +261,13 @@ test("ensureVerified invalidates sentinel on schemaVersion drift", (t) => {
 test("ensureVerified returns sig-invalid on a tampered signature", (t) => {
   _resetWarningState();
   const { privateKey, rawPub } = makeKeypair();
-  const dir = mkPlatformDir(privateKey, { corruptSigFor: `fallow-lsp${ext()}` });
+  const dir = mkPlatformDir(privateKey, { corruptSigFor: `fallow${ext()}` });
   t.after(() => cleanup(dir));
 
   const result = ensureVerified(baseInput(dir, (p) => _verifyWithKey(p, rawPub)));
   assert.equal(result.ok, false);
   assert.equal(result.code, "sig-invalid");
-  assert.match(result.binary, /fallow-lsp/);
+  assert.match(result.binary, /fallow/);
   // Sentinel must NOT have been written on failure
   assert.equal(fs.existsSync(path.join(dir, SENTINEL_FILENAME)), false);
 });

package/scripts/run-binary.js

@@ -146,7 +146,15 @@ function guardBrokenStdout() {
   });
 }
 
-function runBinary(binaryBaseName) {
+// Run the resolved platform binary. `options.prependArgs` (default none) is a
+// list of leading arguments inserted before the process argv, used by the
+// `fallow-lsp` / `fallow-mcp` launcher shims to spawn the multicall binary as
+// `fallow lsp-server` / `fallow mcp-server`. Because the platform packages ship
+// a single `fallow` binary, those shims pass `binaryBaseName = "fallow"` and
+// the subcommand via `prependArgs`; signal, exit-code, and version-line
+// handling stay identical to a bare `fallow` invocation.
+function runBinary(binaryBaseName, options = {}) {
+  const prependArgs = Array.isArray(options.prependArgs) ? options.prependArgs : [];
   guardBrokenStdout();
   const { pkg, manifestPath, platformPkgDir } = resolvePlatformPaths();
   const resolvedVersion = readResolvedVersion(manifestPath);
@@ -166,7 +174,7 @@ function runBinary(binaryBaseName) {
   }
 
   try {
-    execFileSync(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+    execFileSync(binaryPath, [...prependArgs, ...process.argv.slice(2)], { stdio: "inherit" });
   } catch (e) {
     if (e.status === undefined) throw e;
     if (e.status === null) {

package/scripts/run-binary.test.js

@@ -1,10 +1,61 @@
 const test = require("node:test");
 const assert = require("node:assert/strict");
+const fs = require("node:fs");
 const os = require("node:os");
 const { spawnSync } = require("node:child_process");
 const path = require("node:path");
 
 const RUN_BINARY = path.join(__dirname, "run-binary.js");
+const BIN_DIR = path.join(__dirname, "..", "bin");
+
+function currentPlatformPackage() {
+  const { getPlatformPackage } = require("./platform-package");
+  if (process.platform !== "linux") {
+    return getPlatformPackage(process.platform, process.arch);
+  }
+  let libcFamily;
+  try {
+    libcFamily = require("detect-libc").familySync();
+  } catch {
+    libcFamily = undefined;
+  }
+  return getPlatformPackage(process.platform, process.arch, libcFamily);
+}
+
+function runLauncher(t, launcher, args) {
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), "fallow-launcher-"));
+  t.after(() => fs.rmSync(work, { recursive: true, force: true }));
+
+  const pkg = currentPlatformPackage();
+  assert.ok(pkg, "the test host must map to a supported platform package");
+  const pkgDir = path.join(work, "node_modules", ...pkg.split("/"));
+  fs.mkdirSync(pkgDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(pkgDir, "package.json"),
+    JSON.stringify({ name: pkg, version: "3.5.0" }),
+  );
+
+  const binary = path.join(pkgDir, "fallow");
+  fs.writeFileSync(
+    binary,
+    "#!/usr/bin/env node\n" +
+      'require("node:fs").writeFileSync(process.env.FALLOW_TEST_ARGS, JSON.stringify(process.argv.slice(2)));\n',
+  );
+  fs.chmodSync(binary, 0o755);
+
+  const argsFile = path.join(work, "args.json");
+  const result = spawnSync(process.execPath, [path.join(BIN_DIR, launcher), ...args], {
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      NODE_PATH: path.join(work, "node_modules"),
+      FALLOW_SKIP_BINARY_VERIFY: "1",
+      FALLOW_TEST_ARGS: argsFile,
+    },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  return JSON.parse(fs.readFileSync(argsFile, "utf8"));
+}
 
 // Run a child that installs guardBrokenStdout, then emits a synthetic stdout
 // 'error' with the given code. Node delivers a broken-pipe failure as exactly
@@ -91,3 +142,23 @@ test("exitCodeForChildFailure preserves status codes and maps signal deaths", ()
   assert.equal(exitCodeForChildFailure({ status: null, signal: undefined }), 1);
   assert.equal(exitCodeForChildFailure({ status: null, signal: "NOT_A_SIGNAL" }), 1);
 });
+
+test(
+  "fallow-lsp executes the multicall binary with the lsp-server subcommand",
+  { skip: process.platform === "win32" },
+  (t) => {
+    assert.deepEqual(runLauncher(t, "fallow-lsp", ["--stdio"]), ["lsp-server", "--stdio"]);
+  },
+);
+
+test(
+  "fallow-mcp executes the multicall binary with the mcp-server subcommand",
+  { skip: process.platform === "win32" },
+  (t) => {
+    assert.deepEqual(runLauncher(t, "fallow-mcp", ["--transport", "stdio"]), [
+      "mcp-server",
+      "--transport",
+      "stdio",
+    ]);
+  },
+);

package/scripts/verify-binary.js

@@ -293,11 +293,15 @@ function binaryTargetsForPlatform(platformId) {
   // and tests can synthesize a Windows verify without running on Windows.
   const isWindows = typeof platformId === "string" && platformId.startsWith("win32");
   const ext = isWindows ? ".exe" : "";
-  return [
-    { binary: `fallow${ext}`, asset: `fallow-${platformId}${ext}` },
-    { binary: `fallow-lsp${ext}`, asset: `fallow-lsp-${platformId}${ext}` },
-    { binary: `fallow-mcp${ext}`, asset: `fallow-mcp-${platformId}${ext}` },
-  ];
+  // Platform packages ship ONE binary now: the multicall `fallow` (CLI + LSP +
+  // MCP in one engine). The bundled `fallow-lsp` / `fallow-mcp` launchers live
+  // in the wrapper and spawn `fallow lsp-server` / `fallow mcp-server`. The
+  // authoritative digest is the `fallowDigests.fallow` field the release
+  // pipeline embeds for every bundled package; the `asset` below is only the
+  // legacy GitHub-release fallback for pre-embedded-digest packages, which
+  // never shipped this bundled binary, so it is inert for bundled installs and
+  // fails closed (digest-mismatch) in the impossible case it is ever reached.
+  return [{ binary: `fallow${ext}`, asset: `fallow-${platformId}${ext}` }];
 }
 
 function isSkipRequested() {

package/scripts/verify-binary.test.js

@@ -243,7 +243,7 @@ function makePlatformDir(privateKey, options) {
   const opts = options || {};
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "fallow-vbtest-"));
   const ext = process.platform === "win32" ? ".exe" : "";
-  for (const base of ["fallow", "fallow-lsp", "fallow-mcp"]) {
+  for (const base of ["fallow"]) {
     const binaryPath = path.join(dir, `${base}${ext}`);
     const content = Buffer.from(`mock ${base} contents`);
     fs.writeFileSync(binaryPath, content);
@@ -349,7 +349,7 @@ test("verifyInstalled resolves a global npm install from the fallow package dire
   );
 
   const ext = process.platform === "win32" ? ".exe" : "";
-  for (const base of ["fallow", "fallow-lsp", "fallow-mcp"]) {
+  for (const base of ["fallow"]) {
     const binaryPath = path.join(platformDir, `${base}${ext}`);
     const content = Buffer.from(`global install ${base}`);
     fs.writeFileSync(binaryPath, content);
@@ -367,9 +367,9 @@ test("verifyInstalled resolves a global npm install from the fallow package dire
   assert.equal(result.version, "9.9.9");
 });
 
-test("verifyInstalled with dirOverride fails fast on the first bad signature", async (t) => {
+test("verifyInstalled with dirOverride fails on a bad signature", async (t) => {
   const { privateKey, rawPub } = makeKeypair();
-  const dir = makePlatformDir(privateKey, { corruptSigFor: "fallow-lsp" });
+  const dir = makePlatformDir(privateKey, { corruptSigFor: "fallow" });
   t.after(() => cleanup(dir));
   const result = await verifyInstalled({
     dirOverride: dir,
@@ -378,12 +378,12 @@ test("verifyInstalled with dirOverride fails fast on the first bad signature", a
   });
   assert.equal(result.ok, false);
   assert.equal(result.code, "sig-invalid");
-  assert.match(result.binary, /fallow-lsp/);
+  assert.match(result.binary, /fallow/);
 });
 
 test("verifyInstalled with dirOverride reports sig-missing when a .sig is absent", async (t) => {
   const { privateKey, rawPub } = makeKeypair();
-  const dir = makePlatformDir(privateKey, { skipSigFor: "fallow-mcp" });
+  const dir = makePlatformDir(privateKey, { skipSigFor: "fallow" });
   t.after(() => cleanup(dir));
   const result = await verifyInstalled({
     dirOverride: dir,
@@ -392,13 +392,13 @@ test("verifyInstalled with dirOverride reports sig-missing when a .sig is absent
   });
   assert.equal(result.ok, false);
   assert.equal(result.code, "sig-missing");
-  assert.match(result.binary, /fallow-mcp/);
+  assert.match(result.binary, /fallow/);
 });
 
 test("verifyInstalled threads the resolved version into the sig-missing message", async (t) => {
   const { privateKey, rawPub } = makeKeypair();
-  const preDir = makePlatformDir(privateKey, { skipSigFor: "fallow-mcp" });
-  const eraDir = makePlatformDir(privateKey, { skipSigFor: "fallow-mcp" });
+  const preDir = makePlatformDir(privateKey, { skipSigFor: "fallow" });
+  const eraDir = makePlatformDir(privateKey, { skipSigFor: "fallow" });
   t.after(() => {
     cleanup(preDir);
     cleanup(eraDir);
@@ -463,7 +463,7 @@ test("verifyInstalled honors FALLOW_SKIP_BINARY_VERIFY", async (t) => {
 function computeDigestsForDir(dir) {
   const ext = process.platform === "win32" ? ".exe" : "";
   const out = {};
-  for (const base of ["fallow", "fallow-lsp", "fallow-mcp"]) {
+  for (const base of ["fallow"]) {
     const fileName = `${base}${ext}`;
     const full = path.join(dir, fileName);
     out[fileName] =
@@ -549,7 +549,7 @@ test("verifyInstalled falls back to the provider when the embedded digest is mis
     },
   });
   assert.equal(result.ok, true);
-  assert.equal(providerCalls, 3);
+  assert.equal(providerCalls, 1);
 });
 
 test("verifyInstalled falls back to the provider when fallowDigests is partial / malformed", async (t) => {
@@ -573,8 +573,8 @@ test("verifyInstalled falls back to the provider when fallowDigests is partial /
     },
   });
   assert.equal(result.ok, true);
-  // One call per binary because all three entries fail to normalize.
-  assert.equal(providerCalls, 3);
+  // One call for the single shipped binary because its entry fails to normalize.
+  assert.equal(providerCalls, 1);
 });
 
 test("verifyInstalled returns digest-mismatch when the embedded digest disagrees with the binary", async (t) => {
@@ -587,8 +587,6 @@ test("verifyInstalled returns digest-mismatch when the embedded digest disagrees
     version: "1.0.0",
     fallowDigests: {
       [`fallow${ext}`]: "sha256:" + "a".repeat(64),
-      [`fallow-lsp${ext}`]: "sha256:" + "a".repeat(64),
-      [`fallow-mcp${ext}`]: "sha256:" + "a".repeat(64),
     },
   });
   const result = await verifyInstalled({
@@ -644,9 +642,9 @@ test("verifyInstalledSync with embedded digests returns ok end-to-end", (t) => {
   assert.equal(result.package, "<override>");
 });
 
-test("verifyInstalledSync fails fast on first bad signature", (t) => {
+test("verifyInstalledSync fails on a bad signature", (t) => {
   const { privateKey, rawPub } = makeKeypair();
-  const dir = makePlatformDir(privateKey, { corruptSigFor: "fallow-lsp" });
+  const dir = makePlatformDir(privateKey, { corruptSigFor: "fallow" });
   t.after(() => cleanup(dir));
   writeManifest(dir, {
     name: "@fallow-cli/x",
@@ -659,7 +657,7 @@ test("verifyInstalledSync fails fast on first bad signature", (t) => {
   });
   assert.equal(result.ok, false);
   assert.equal(result.code, "sig-invalid");
-  assert.match(result.binary, /fallow-lsp/);
+  assert.match(result.binary, /fallow/);
 });
 
 test("verifyInstalledSync reports digest-mismatch when bytes diverge from embedded digest", (t) => {
@@ -671,11 +669,7 @@ test("verifyInstalledSync reports digest-mismatch when bytes diverge from embedd
     version: "9.9.9",
     fallowDigests: {
       fallow: "sha256:" + "a".repeat(64),
-      "fallow-lsp": "sha256:" + "a".repeat(64),
-      "fallow-mcp": "sha256:" + "a".repeat(64),
       "fallow.exe": "sha256:" + "a".repeat(64),
-      "fallow-lsp.exe": "sha256:" + "a".repeat(64),
-      "fallow-mcp.exe": "sha256:" + "a".repeat(64),
     },
   });
   const result = verifyInstalledSync({