@smoothbricks/cli 0.11.10 → 0.11.12

package/dist/monorepo/cargo-policy.d.ts

@@ -1,2 +1,26 @@
-export declare function validateCargoCachePolicy(root: string): number;
+/**
+ * The one command this policy shells out to, behind a seam. `cargo hakari
+ * verify` is the only authority on whether a generated workspace-hack still
+ * unifies what the workspace resolves today; nothing in these files can answer
+ * that. Tests supply their own so the policy stays runnable without the binary.
+ */
+export interface CargoHakariShell {
+    run(directory: string, args: readonly string[]): {
+        code: number;
+        output: string;
+        missing: boolean;
+    };
+}
+export interface CargoPolicyOptions {
+    /** Injected in tests; production shells out to the real `cargo hakari`. */
+    shell?: CargoHakariShell;
+}
+export declare function validateCargoCachePolicy(root: string, options?: CargoPolicyOptions): number;
+/**
+ * The fix `smoo monorepo update` applies for the policy above: write the
+ * nightly resolver configuration, or generate and wire the workspace-hack a
+ * stable toolchain needs. Both are idempotent — the second run of either does
+ * nothing — because update runs on every repository, not only broken ones.
+ */
+export declare function applyCargoFeatureUnification(root: string, options?: CargoPolicyOptions): void;
 //# sourceMappingURL=cargo-policy.d.ts.map

package/dist/monorepo/cargo-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cargo-policy.d.ts","sourceRoot":"","sources":["../../src/monorepo/cargo-policy.ts"],"names":[],"mappings":"AAqjBA,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiD7D"}
+{"version":3,"file":"cargo-policy.d.ts","sourceRoot":"","sources":["../../src/monorepo/cargo-policy.ts"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CACrG;AAusBD,MAAM,WAAW,kBAAkB;IACjC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAwD/F;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,IAAI,CA8BjG"}

package/dist/monorepo/cargo-policy.js

@@ -2,12 +2,13 @@ import * as _accessExpressionAsString_1 from "typia/lib/internal/_accessExpressi
 const __typia_transform__accessExpressionAsString = _accessExpressionAsString_1._accessExpressionAsString;
 import * as _validateReport_1 from "typia/lib/internal/_validateReport";
 import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import typia from 'typia';
 import { parsePackageJsonText } from '../lib/json.js';
 const validateCargoManifest = (() => {
-    const _io0 = input => (undefined === input.workspace || "object" === typeof input.workspace && null !== input.workspace && false === Array.isArray(input.workspace) && _io1(input.workspace)) && (undefined === input["package"] || "object" === typeof input["package"] && null !== input["package"] && false === Array.isArray(input["package"]) && _io2(input["package"])) && (undefined === input.profile || "object" === typeof input.profile && null !== input.profile && false === Array.isArray(input.profile) && _io3(input.profile));
+    const _io0 = input => (undefined === input.workspace || "object" === typeof input.workspace && null !== input.workspace && false === Array.isArray(input.workspace) && _io1(input.workspace)) && (undefined === input["package"] || "object" === typeof input["package"] && null !== input["package"] && false === Array.isArray(input["package"]) && _io2(input["package"])) && (undefined === input.profile || "object" === typeof input.profile && null !== input.profile && false === Array.isArray(input.profile) && _io3(input.profile)) && (undefined === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && _io5(input.dependencies)) && (undefined === input["dev-dependencies"] || "object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) && _io5(input["dev-dependencies"])) && (undefined === input["build-dependencies"] || "object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) && _io5(input["build-dependencies"]));
     const _io1 = input => (undefined === input.members || Array.isArray(input.members) && input.members.every(elem => "string" === typeof elem)) && (undefined === input.exclude || Array.isArray(input.exclude) && input.exclude.every(elem => "string" === typeof elem));
     const _io2 = input => (undefined === input.name || "string" === typeof input.name) && (undefined === input.workspace || "string" === typeof input.workspace || "boolean" === typeof input.workspace);
     const _io3 = input => Object.keys(input).every(key => {
@@ -17,6 +18,12 @@ const validateCargoManifest = (() => {
         return "object" === typeof value && null !== value && false === Array.isArray(value) && _io4(value);
     });
     const _io4 = input => (undefined === input.inherits || "string" === typeof input.inherits) && (undefined === input.incremental || "boolean" === typeof input.incremental) && (undefined === input.debug || "string" === typeof input.debug || "number" === typeof input.debug || "boolean" === typeof input.debug) && (undefined === input["split-debuginfo"] || "string" === typeof input["split-debuginfo"]) && (null !== input["trim-paths"] && (undefined === input["trim-paths"] || "string" === typeof input["trim-paths"] || "boolean" === typeof input["trim-paths"] || Array.isArray(input["trim-paths"]) && input["trim-paths"].every(elem => "string" === typeof elem)));
+    const _io5 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
     const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.workspace || ("object" === typeof input.workspace && null !== input.workspace && false === Array.isArray(input.workspace) || _report(_exceptionable, {
             path: _path + ".workspace",
             expected: "(undefined | { members?: string[] | undefined; exclude?: string[] | undefined; })",
@@ -41,6 +48,30 @@ const validateCargoManifest = (() => {
             path: _path + ".profile",
             expected: "(Record<string, CargoProfile> | undefined)",
             value: input.profile
+        }), undefined === input.dependencies || ("object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) || _report(_exceptionable, {
+            path: _path + ".dependencies",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input.dependencies
+        })) && _vo5(input.dependencies, _path + ".dependencies", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".dependencies",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input.dependencies
+        }), undefined === input["dev-dependencies"] || ("object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) || _report(_exceptionable, {
+            path: _path + "[\"dev-dependencies\"]",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input["dev-dependencies"]
+        })) && _vo5(input["dev-dependencies"], _path + "[\"dev-dependencies\"]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + "[\"dev-dependencies\"]",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input["dev-dependencies"]
+        }), undefined === input["build-dependencies"] || ("object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) || _report(_exceptionable, {
+            path: _path + "[\"build-dependencies\"]",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input["build-dependencies"]
+        })) && _vo5(input["build-dependencies"], _path + "[\"build-dependencies\"]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + "[\"build-dependencies\"]",
+            expected: "(Record<string, unknown> | undefined)",
+            value: input["build-dependencies"]
         })].every(flag => flag);
     const _vo1 = (input, _path, _exceptionable = true) => [undefined === input.members || (Array.isArray(input.members) || _report(_exceptionable, {
             path: _path + ".members",
@@ -123,6 +154,12 @@ const validateCargoManifest = (() => {
             expected: "(Array<string> | boolean | string | undefined)",
             value: input["trim-paths"]
         }))].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        }).every(flag => flag)].every(flag => flag);
     const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
     let errors;
     let _report;
@@ -175,7 +212,7 @@ const validateCargoConfig = (() => {
         expected: "(Array<string> | string | undefined)",
         value: input["rustflags"]
     }));
-    const _io0 = input => (undefined === input.build || "object" === typeof input.build && null !== input.build && false === Array.isArray(input.build) && _io1(input.build)) && (undefined === input.target || "object" === typeof input.target && null !== input.target && false === Array.isArray(input.target) && _io2(input.target)) && (undefined === input.env || "object" === typeof input.env && null !== input.env && false === Array.isArray(input.env) && _io4(input.env));
+    const _io0 = input => (undefined === input.build || "object" === typeof input.build && null !== input.build && false === Array.isArray(input.build) && _io1(input.build)) && (undefined === input.target || "object" === typeof input.target && null !== input.target && false === Array.isArray(input.target) && _io2(input.target)) && (undefined === input.env || "object" === typeof input.env && null !== input.env && false === Array.isArray(input.env) && _io4(input.env)) && (undefined === input.resolver || "object" === typeof input.resolver && null !== input.resolver && false === Array.isArray(input.resolver) && _io6(input.resolver)) && (undefined === input.unstable || "object" === typeof input.unstable && null !== input.unstable && false === Array.isArray(input.unstable) && _io7(input.unstable));
     const _io1 = input => (undefined === input["target-dir"] || "string" === typeof input["target-dir"]) && _ip0(input) && (undefined === input.incremental || "boolean" === typeof input.incremental);
     const _io2 = input => Object.keys(input).every(key => {
         const value = input[key];
@@ -191,6 +228,8 @@ const validateCargoConfig = (() => {
         return null !== value && undefined !== value && ("string" === typeof value || "object" === typeof value && null !== value && false === Array.isArray(value) && _io5(value));
     });
     const _io5 = input => (undefined === input.value || "string" === typeof input.value) && (undefined === input.relative || "boolean" === typeof input.relative) && (undefined === input.force || "boolean" === typeof input.force);
+    const _io6 = input => undefined === input["feature-unification"] || "string" === typeof input["feature-unification"];
+    const _io7 = input => undefined === input["feature-unification"] || "boolean" === typeof input["feature-unification"];
     const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.build || ("object" === typeof input.build && null !== input.build && false === Array.isArray(input.build) || _report(_exceptionable, {
             path: _path + ".build",
             expected: _ve0,
@@ -215,6 +254,22 @@ const validateCargoConfig = (() => {
             path: _path + ".env",
             expected: "(Record<string, string | CargoConfigEnvObject> | undefined)",
             value: input.env
+        }), undefined === input.resolver || ("object" === typeof input.resolver && null !== input.resolver && false === Array.isArray(input.resolver) || _report(_exceptionable, {
+            path: _path + ".resolver",
+            expected: "(undefined | { 'feature-unification'?: string | undefined; })",
+            value: input.resolver
+        })) && _vo6(input.resolver, _path + ".resolver", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".resolver",
+            expected: "(undefined | { 'feature-unification'?: string | undefined; })",
+            value: input.resolver
+        }), undefined === input.unstable || ("object" === typeof input.unstable && null !== input.unstable && false === Array.isArray(input.unstable) || _report(_exceptionable, {
+            path: _path + ".unstable",
+            expected: "(undefined | { 'feature-unification'?: boolean | undefined; })",
+            value: input.unstable
+        })) && _vo7(input.unstable, _path + ".unstable", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".unstable",
+            expected: "(undefined | { 'feature-unification'?: boolean | undefined; })",
+            value: input.unstable
         })].every(flag => flag);
     const _vo1 = (input, _path, _exceptionable = true) => [undefined === input["target-dir"] || "string" === typeof input["target-dir"] || _report(_exceptionable, {
             path: _path + "[\"target-dir\"]",
@@ -279,6 +334,16 @@ const validateCargoConfig = (() => {
             expected: "(boolean | undefined)",
             value: input.force
         })].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => [undefined === input["feature-unification"] || "string" === typeof input["feature-unification"] || _report(_exceptionable, {
+            path: _path + "[\"feature-unification\"]",
+            expected: "(string | undefined)",
+            value: input["feature-unification"]
+        })].every(flag => flag);
+    const _vo7 = (input, _path, _exceptionable = true) => [undefined === input["feature-unification"] || "boolean" === typeof input["feature-unification"] || _report(_exceptionable, {
+            path: _path + "[\"feature-unification\"]",
+            expected: "(boolean | undefined)",
+            value: input["feature-unification"]
+        })].every(flag => flag);
     const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
     let errors;
     let _report;
@@ -311,6 +376,118 @@ const validateCargoConfig = (() => {
         };
     });
 })();
+const validateRustToolchainFile = (() => {
+    const _io0 = input => undefined === input.toolchain || "object" === typeof input.toolchain && null !== input.toolchain && false === Array.isArray(input.toolchain) && _io1(input.toolchain);
+    const _io1 = input => undefined === input.channel || "string" === typeof input.channel;
+    const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.toolchain || ("object" === typeof input.toolchain && null !== input.toolchain && false === Array.isArray(input.toolchain) || _report(_exceptionable, {
+            path: _path + ".toolchain",
+            expected: "(undefined | { channel?: string | undefined; })",
+            value: input.toolchain
+        })) && _vo1(input.toolchain, _path + ".toolchain", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".toolchain",
+            expected: "(undefined | { channel?: string | undefined; })",
+            value: input.toolchain
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => [undefined === input.channel || "string" === typeof input.channel || _report(_exceptionable, {
+            path: _path + ".channel",
+            expected: "(string | undefined)",
+            value: input.channel
+        })].every(flag => flag);
+    const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+    let errors;
+    let _report;
+    return _createStandardSchema_1._createStandardSchema(input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport_1._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+                path: _path + "",
+                expected: "RustToolchainFile",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "RustToolchainFile",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    });
+})();
+const validateHakariConfig = (() => {
+    const _io0 = input => undefined === input["hakari-package"] || "string" === typeof input["hakari-package"];
+    const _vo0 = (input, _path, _exceptionable = true) => [undefined === input["hakari-package"] || "string" === typeof input["hakari-package"] || _report(_exceptionable, {
+            path: _path + "[\"hakari-package\"]",
+            expected: "(string | undefined)",
+            value: input["hakari-package"]
+        })].every(flag => flag);
+    const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+    let errors;
+    let _report;
+    return _createStandardSchema_1._createStandardSchema(input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport_1._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+                path: _path + "",
+                expected: "HakariConfig",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "HakariConfig",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    });
+})();
+const defaultHakariShell = {
+    run(directory, args) {
+        const result = spawnSync('cargo', ['hakari', ...args], { cwd: directory, encoding: 'utf8' });
+        const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+        // cargo itself exists; a missing subcommand is cargo's own error, not ENOENT.
+        const missing = result.error?.code === 'ENOENT' || output.includes('no such command');
+        return { code: result.status ?? 1, output, missing };
+    },
+};
+/** Cargo's nightly-only workspace feature unification, and the config that turns it on. */
+const RESOLVER_UNIFICATION_BLOCK = [
+    '# One feature resolution for the whole workspace. Without it every per-crate',
+    '# cargo invocation resolves features for its own selection, so one shared',
+    '# dependency is compiled once per selection and no warm target directory is',
+    '# reused across crates. Requires the nightly channel the managed devenv',
+    '# module pins; on a stable toolchain a cargo-hakari workspace-hack does the',
+    '# same job. Both keys are needed: cargo ignores [resolver] without the',
+    '# [unstable] opt-in.',
+    '[unstable]',
+    'feature-unification = true',
+    '',
+    '[resolver]',
+    'feature-unification = "workspace"',
+].join('\n');
 const SKIPPED_DIRECTORY_NAMES = new Set([
     'node_modules',
     'target',
@@ -488,6 +665,143 @@ function hasAncestorWorkspace(manifest, workspaceRoots) {
             return path !== '' && path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path);
         })());
 }
+/**
+ * The channel that will actually compile this repository.
+ *
+ * The managed devenv module wins when it exists: devenv resolves the toolchain
+ * through rust-overlay and ignores `rust-toolchain.toml` unless
+ * `languages.rust.toolchainFile` names it, so a rust-toolchain file beside that
+ * module is decoration. Without the module, rustup's file is the answer. With
+ * neither, stable is the safe verdict: it is the channel on which the nightly
+ * resolver keys silently do nothing.
+ */
+function isNightlyToolchain(repositoryRoot, workspaceDirectory) {
+    const devenvModule = join(repositoryRoot, 'tooling/direnv/devenv.smoo.nix');
+    if (existsSync(devenvModule)) {
+        const text = readFileSync(devenvModule, 'utf8');
+        const rustIndex = text.indexOf('languages.rust');
+        const channel = rustIndex === -1 ? null : /channel\s*=\s*"([^"]+)"/.exec(text.slice(rustIndex))?.[1];
+        return channel?.startsWith('nightly') === true;
+    }
+    for (const directory of [workspaceDirectory, repositoryRoot]) {
+        const path = join(directory, 'rust-toolchain.toml');
+        if (!existsSync(path)) {
+            continue;
+        }
+        try {
+            const validation = validateRustToolchainFile(Bun.TOML.parse(readFileSync(path, 'utf8')));
+            return validation.success && validation.data.toolchain?.channel?.startsWith('nightly') === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Cargo merges `.cargo/config.toml` from the invocation directory upward, with
+ * the deepest file winning. Only the configs at or above the workspace root can
+ * govern a command run there, so the effective value is the deepest of those.
+ */
+function effectiveConfigValue(configs, workspaceDirectory, read) {
+    let deepest = null;
+    for (const loaded of configs) {
+        const directory = dirname(dirname(loaded.path));
+        if (!pathWithin(directory, workspaceDirectory)) {
+            continue;
+        }
+        const value = read(loaded.config);
+        if (value === undefined) {
+            continue;
+        }
+        if (deepest === null || directory.length > deepest.directory.length) {
+            deepest = { directory, value };
+        }
+    }
+    return deepest?.value;
+}
+function workspaceCrates(root, manifests) {
+    const members = manifests.filter((manifest) => workspaceContains(root, manifest));
+    return root.manifest.package === undefined ? members : [root, ...members];
+}
+const FEATURE_UNIFICATION_FIX = 'Run: smoo monorepo update';
+/**
+ * A workspace of two or more crates must resolve features ONCE for all of them.
+ *
+ * Without that, every per-crate cargo invocation resolves features for its own
+ * selection, and one shared dependency is compiled once per selection: the same
+ * `nx run cargo-test-<crate>` that should reuse a warm target directory rebuilds
+ * its half of the graph instead. Cargo's own mechanism is nightly-only, so a
+ * stable toolchain reaches the identical result through a cargo-hakari
+ * workspace-hack — a generated crate that depends on the union of features, which
+ * every member then depends on.
+ *
+ * One crate needs neither: there is only one selection to unify.
+ */
+function featureUnificationPolicy(repositoryRoot, workspaceRoots, manifests, configs, shell) {
+    let failures = 0;
+    for (const root of workspaceRoots) {
+        const crates = workspaceCrates(root, manifests);
+        if (crates.length < 2) {
+            continue;
+        }
+        const nightly = isNightlyToolchain(repositoryRoot, root.directory);
+        const resolver = effectiveConfigValue(configs, root.directory, (config) => config.resolver?.['feature-unification']);
+        const unstable = effectiveConfigValue(configs, root.directory, (config) => config.unstable?.['feature-unification']);
+        if (nightly && resolver === 'workspace') {
+            if (unstable !== true) {
+                failures += report(join(root.directory, '.cargo/config.toml'), 'sets [resolver] feature-unification = "workspace" without [unstable] feature-unification = true, ' +
+                    `so cargo ignores it and every crate still resolves features on its own. ${FEATURE_UNIFICATION_FIX}`);
+            }
+            continue;
+        }
+        if (existsSync(join(root.directory, '.config/hakari.toml'))) {
+            failures += hakariWorkspaceHackPolicy(root, crates, shell);
+            continue;
+        }
+        failures += report(root.path, `workspace of ${crates.length} crates has no workspace-wide feature unification: ` +
+            (nightly
+                ? 'add [unstable] feature-unification = true and [resolver] feature-unification = "workspace" to .cargo/config.toml'
+                : 'the [resolver] feature-unification key needs the nightly channel, so this stable toolchain needs a ' +
+                    'cargo-hakari workspace-hack (.config/hakari.toml)') +
+            `. Every per-crate cargo invocation otherwise recompiles the shared graph for its own feature selection. ${FEATURE_UNIFICATION_FIX}`);
+    }
+    return failures;
+}
+function hakariWorkspaceHackPolicy(root, crates, shell) {
+    const configPath = join(root.directory, '.config/hakari.toml');
+    let hackName;
+    try {
+        const validation = validateHakariConfig(Bun.TOML.parse(readFileSync(configPath, 'utf8')));
+        hackName = validation.success ? validation.data['hakari-package'] : undefined;
+    }
+    catch {
+        hackName = undefined;
+    }
+    if (hackName === undefined || hackName.length === 0) {
+        return report(configPath, `must declare hakari-package = "<crate>". ${FEATURE_UNIFICATION_FIX}`);
+    }
+    const hack = crates.find((crate) => crate.manifest.package?.name === hackName);
+    if (hack === undefined) {
+        return report(configPath, `names hakari-package "${hackName}", which is not a member of this workspace. ${FEATURE_UNIFICATION_FIX}`);
+    }
+    const unwired = crates
+        .filter((crate) => crate !== hack)
+        .filter((crate) => ![crate.manifest.dependencies, crate.manifest['dev-dependencies'], crate.manifest['build-dependencies']].some((table) => table !== undefined && hackName in table))
+        .map((crate) => crate.manifest.package?.name ?? crate.path);
+    if (unwired.length > 0) {
+        return report(root.path, `these crates do not depend on "${hackName}", so cargo-hakari cannot unify their features: ` +
+            `${unwired.join(', ')}. ${FEATURE_UNIFICATION_FIX}`);
+    }
+    const verify = shell.run(root.directory, ['verify']);
+    if (verify.missing) {
+        return report(configPath, 'needs cargo-hakari, which is not installed; the managed devenv module provides it — reload the shell (direnv reload).');
+    }
+    if (verify.code !== 0) {
+        return report(root.path, `cargo hakari verify rejected the workspace-hack: ${verify.output || 'no output'}. ${FEATURE_UNIFICATION_FIX}`);
+    }
+    return 0;
+}
 function isWorkspaceMember(manifest, workspaceRoots) {
     if (manifest.manifest.package?.workspace !== undefined) {
         return true;
@@ -738,7 +1052,7 @@ function reportManifestDirectoryAdvisories(repositoryRoot, ignoredDirectories) {
         console.error(`${advisory.path}:${advisory.line}: env!("CARGO_MANIFEST_DIR") is not path-stable; the patched sccache never normalises env-dep values, so this crate and everything downstream misses on every workspace at a new mount path. Fix it by removing the macro from production code or replacing it with a path-stable value.`);
     }
 }
-export function validateCargoCachePolicy(root) {
+export function validateCargoCachePolicy(root, options = {}) {
     const repositoryRoot = resolve(root);
     const discoveredManifestPaths = discoverFiles(repositoryRoot, (name) => name === 'Cargo.toml');
     const ignoredDirectories = discoverIgnoredSubtrees(discoveredManifestPaths);
@@ -767,6 +1081,7 @@ export function validateCargoCachePolicy(root) {
     }
     const workspaceRoots = manifests.filter((loaded) => loaded.manifest.workspace !== undefined);
     failures += reportManifestPolicy(manifests, workspaceRoots);
+    failures += featureUnificationPolicy(repositoryRoot, workspaceRoots, manifests, configs, options.shell ?? defaultHakariShell);
     failures += cargoIncrementalPolicy(repositoryRoot, configs, packageJsonPaths, justfilePaths, ignoredDirectories);
     for (const config of configs) {
         failures += configPolicy(config, repositoryRoot);
@@ -774,3 +1089,80 @@ export function validateCargoCachePolicy(root) {
     reportManifestDirectoryAdvisories(repositoryRoot, ignoredDirectories);
     return failures;
 }
+/**
+ * The fix `smoo monorepo update` applies for the policy above: write the
+ * nightly resolver configuration, or generate and wire the workspace-hack a
+ * stable toolchain needs. Both are idempotent — the second run of either does
+ * nothing — because update runs on every repository, not only broken ones.
+ */
+export function applyCargoFeatureUnification(root, options = {}) {
+    const repositoryRoot = resolve(root);
+    const shell = options.shell ?? defaultHakariShell;
+    const discoveredManifestPaths = discoverFiles(repositoryRoot, (name) => name === 'Cargo.toml');
+    const manifestPaths = filterIgnoredPaths(discoveredManifestPaths, discoverIgnoredSubtrees(discoveredManifestPaths));
+    const manifests = [];
+    for (const path of manifestPaths) {
+        const manifest = loadManifest(path);
+        if (manifest !== null) {
+            manifests.push({ path, directory: dirname(path), manifest });
+        }
+    }
+    for (const root of manifests.filter((loaded) => loaded.manifest.workspace !== undefined)) {
+        if (workspaceCrates(root, manifests).length < 2) {
+            continue;
+        }
+        if (isNightlyToolchain(repositoryRoot, root.directory)) {
+            writeResolverUnification(root.directory);
+            continue;
+        }
+        const hakariConfig = join(root.directory, '.config/hakari.toml');
+        const relativeRoot = relative(repositoryRoot, root.directory) || '.';
+        if (!existsSync(hakariConfig)) {
+            console.log(`generating     cargo workspace-hack in ${relativeRoot} (cargo hakari init workspace-hack)`);
+            runHakari(shell, root.directory, ['init', 'workspace-hack']);
+        }
+        console.log(`unifying       cargo features in ${relativeRoot} (cargo hakari generate, manage-deps)`);
+        runHakari(shell, root.directory, ['generate']);
+        runHakari(shell, root.directory, ['manage-deps', '--yes']);
+    }
+}
+function runHakari(shell, directory, args) {
+    const result = shell.run(directory, args);
+    if (result.missing) {
+        console.error(`cargo hakari is not installed, so the workspace-hack in ${directory} was not updated; the managed devenv module provides it — reload the shell (direnv reload).`);
+        return;
+    }
+    if (result.code !== 0) {
+        console.error(`cargo hakari ${args.join(' ')} failed in ${directory}: ${result.output || 'no output'}`);
+    }
+}
+/**
+ * Append the two keys, never rewrite the file. A `.cargo/config.toml` carries
+ * linkers, env and target settings whose ORDER and comments are load-bearing;
+ * re-emitting parsed TOML would lose both. If either table already exists with
+ * some other content, appending a second one is invalid TOML — so that case is
+ * reported for a human instead of being guessed at.
+ */
+function writeResolverUnification(workspaceDirectory) {
+    const path = join(workspaceDirectory, '.cargo/config.toml');
+    const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
+    if (existing === null) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, `${RESOLVER_UNIFICATION_BLOCK}\n`);
+        console.log(`writing        ${path}`);
+        return;
+    }
+    const parsed = loadConfig(path);
+    if (parsed === null) {
+        return;
+    }
+    if (parsed.resolver?.['feature-unification'] === 'workspace' && parsed.unstable?.['feature-unification'] === true) {
+        return;
+    }
+    if (parsed.resolver !== undefined || parsed.unstable !== undefined) {
+        console.error(`${path}: already declares [resolver] or [unstable]; add feature-unification to the existing tables by hand:\n${RESOLVER_UNIFICATION_BLOCK}`);
+        return;
+    }
+    writeFileSync(path, `${existing.replace(/\n*$/, '\n')}\n${RESOLVER_UNIFICATION_BLOCK}\n`);
+    console.log(`updating       ${path}`);
+}

package/dist/monorepo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monorepo/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AA2BxD,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAQpF;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBjG;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAcpE;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBrG;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElE;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,GAAE,4BAAiC,EAC1C,IAAI,SAAgB,GACnB,IAAI,CAoBN;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,0BAA+B,GAAG,MAAM,CAW3G;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAI5D;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,uBAAuB,EAChC,KAAK,GAAE,qBAAoD,GAC1D,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAED,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monorepo/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AA2BxD,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAQpF;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBjG;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBpE;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBrG;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElE;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,GAAE,4BAAiC,EAC1C,IAAI,SAAgB,GACnB,IAAI,CAoBN;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,0BAA+B,GAAG,MAAM,CAW3G;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAI5D;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,uBAAuB,EAChC,KAAK,GAAE,qBAAoD,GAC1D,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAED,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/monorepo/index.js

@@ -2,7 +2,7 @@ import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
 import { printCommandOutput, run, runResult } from '../lib/run.js';
 import { escapeRegex, getWorkspacePackages, getWorkspacePatterns, listReleasePackages } from '../lib/workspace.js';
 import { readProjectTargets } from '../nx/index.js';
-import { validateCargoCachePolicy } from './cargo-policy.js';
+import { applyCargoFeatureUnification, validateCargoCachePolicy } from './cargo-policy.js';
 import { formatCommitMessage, stagedDeletedPublicPackages, validateBreakingDisclosure, validateCommitMessage, } from './commit-msg.js';
 import { applyWorkspaceGitConfig } from './git-config.js';
 import { syncBunLockfileVersions } from './lockfile.js';
@@ -49,6 +49,10 @@ export async function updateManagedFiles(root) {
     // Tool dependency policy (typescript API 6, @typescript/native for ttsc, nx, …)
     // lives next to managed templates — update must install them, not only rewrite files.
     await applyToolConfigDefaults(root);
+    // Rust's half of the same job: a multi-crate Cargo workspace must resolve
+    // features once for every member, or each per-crate cargo invocation
+    // recompiles the shared graph for its own selection.
+    applyCargoFeatureUnification(root);
     syncBunLockfileVersions(root, { mode: 'install' });
     console.log('installing     workspace dependencies (bun install)');
     await run('bun', ['install', '--no-summary'], root);

package/dist/monorepo/packs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/monorepo/packs/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,cAAc,EAAsB,MAAM,mBAAmB,CAAC;AAM5E,OAAO,EAKL,KAAK,sBAAsB,EAS5B,MAAM,sBAAsB,CAAC;AAU9B,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClD,WAAW,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzD,YAAY,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,gBAAgB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAClE,iBAAiB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CACpE;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC9F;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAkID,0DAA0D;AAC1D,eAAO,MAAM,YAAY,gBAAQ,CAAC;AAElC,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAItE;AAED,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,eAAe,EACpB,OAAO,GAAE,mBAAwB,EACjC,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CA0B7B;AAuMD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAexG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/monorepo/packs/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,cAAc,EAAsB,MAAM,mBAAmB,CAAC;AAO5E,OAAO,EAKL,KAAK,sBAAsB,EAS5B,MAAM,sBAAsB,CAAC;AAU9B,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClD,WAAW,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzD,YAAY,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,gBAAgB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAClE,iBAAiB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CACpE;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC9F;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AA8ID,0DAA0D;AAC1D,eAAO,MAAM,YAAY,gBAAQ,CAAC;AAElC,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAItE;AAED,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,eAAe,EACpB,OAAO,GAAE,mBAAwB,EACjC,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CA0B7B;AAuMD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAexG"}

package/dist/monorepo/packs/index.js

@@ -2,6 +2,7 @@ import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { printCommandOutput, runResult, runStatus } from '../../lib/run.js';
 import { readProjectTargets } from '../../nx/index.js';
+import { applyCargoFeatureUnification, validateCargoCachePolicy } from '../cargo-policy.js';
 import { validateGoToolchainAgreement } from '../go-toolchain.js';
 import { syncBunLockfileVersions, validateBunLockfileVersions } from '../lockfile.js';
 import { validateDevenvModuleImport, warnOnManagedFileDrift } from '../managed-files.js';
@@ -64,6 +65,18 @@ const packs = [
             return validateDevenvModuleImport(ctx.root);
         },
     },
+    {
+        // Cargo's build-cache and feature-unification conventions. `--fix` writes
+        // the workspace feature unification a multi-crate workspace needs; the rest
+        // of the policy is a verdict a human has to act on.
+        name: 'cargo',
+        fixPreBuild(ctx) {
+            applyCargoFeatureUnification(ctx.root);
+        },
+        validatePreBuild(ctx) {
+            return validateCargoCachePolicy(ctx.root);
+        },
+    },
     {
         name: 'publishing',
         init(ctx) {

package/managed/raw/tooling/direnv/devenv.smoo.nix

@@ -221,6 +221,12 @@
     # variants per crate and 26 GB of junk before this existed), and a sweep
     # prunes them without touching the warm current-fingerprint surface.
     pkgs.cargo-sweep
+    # The stable-toolchain arm of smoo's workspace feature-unification policy:
+    # `cargo hakari` generates and wires the workspace-hack crate that unifies
+    # features when `[resolver] feature-unification` — nightly-only, and what
+    # the channel above selects — is unavailable. `smoo monorepo validate` runs
+    # `cargo hakari verify` for a workspace that took that route.
+    pkgs.cargo-hakari
   ];
 
   enterShell = lib.mkMerge [