@bobfrankston/npmglobalize 1.0.220 → 1.0.222

package/README.md

@@ -172,15 +172,57 @@ exits 0 — e.g. `@bobfrankston/msger`'s postinstall copies its native binary
 into the per-user bin dir its launcher reads from, and skipping it leaves a
 stale exe behind a green checkmark.
 
-npmglobalize therefore allowlists **your own packages** on the global install
-it performs — it just built and published them from your source, so they're
-trusted — and leaves third-party packages gated:
-
-```
-> npm install -g @bobfrankston/winpos@2.0.51 --allow-scripts @bobfrankston/winpos,@bobfrankston/msger,@bobfrankston/msgcommon
-```
-
-Anything npm skips is reported rather than buried in the captured output:
+A **project** install is the opposite case: npm *rejects* `--allow-scripts`
+there and reads the policy from the `allowScripts` field of the root
+`package.json` (maintained by `npm approve-scripts` / `npm deny-scripts`),
+falling back to `allow-scripts` in `.npmrc` only when the field is absent.
+Until that field covers everything installed, every `npm install` ends with a
+`npm warn allow-scripts … not yet covered by allowScripts` block.
+
+npmglobalize keeps that field current, once per run, right after the
+node_modules check:
+
+- **Own-scope packages and `file:` deps are approved without asking** — they
+  are your source.
+- **Each third-party package is asked about**, showing the script npm would
+  run and whether it is a prebuilt-binary fetcher:
+
+  ```
+  npm gates install scripts for 2 third-party package(s) in @bobfrankston/whts. Approvals are recorded in package.json "allowScripts" (name-only) and honored on the global install too.
+    Allow install scripts for sharp@0.33.5 (install: node install/check)?  [y]es / [n]o, deny / [a]ll remaining / [s]kip for now: y
+    Allow install scripts for koffi@2.14.1|2.16.1 (install: node src/cnoke/cnoke.js --prebuild) — prebuilt-binary fetcher, the package ships binaries?  [y]es / [n]o, deny / [a]ll remaining / [s]kip for now: y
+    ✓ allowScripts: approved @bobfrankston/msger, com-wrapper, sharp, koffi (2 own/local approved automatically)
+  ```
+
+  `y` approves, `n` records a deny (`"pkg": false`, npm's own mechanism — the
+  question is not repeated; delete the entry to reconsider), `a` approves
+  everything remaining, `s` leaves it pending for next time. Approvals are
+  **name-only** (`--no-allow-scripts-pin`): a version pin would re-open the
+  question on every bump. Without a terminal (piped stdin) nothing is asked;
+  the pending packages are listed with the command to approve them.
+- The field is written by npm itself, so a linked dep gets the key npm wants
+  for it — the `file:` spec, e.g. `"file:../../../../projects/com/com-wrapper": true`
+  (relative to the link's parent directory, not the project).
+
+The **global** install then allowlists your own packages — it just built and
+published them from your source, so they're trusted — plus whatever the
+project's `allowScripts` approved (a `file:` key is mapped to that dep's
+published name) and your user `.npmrc` `allow-scripts` list, minus anything
+the project denied. Third-party packages you never approved stay gated:
+
+```
+> npm install -g @bobfrankston/winpos@2.0.51 --allow-scripts @bobfrankston/winpos,@bobfrankston/msger,@bobfrankston/msgcommon,sharp
+```
+
+npm takes the allowlist from the *first* source that has one rather than
+merging — CLI flag, then `package.json`, then `.npmrc` — which is why the
+`.npmrc` list is folded into the flag here, and why npm prints
+`.npmrc allow-scripts setting is being ignored because package.json declares
+its own allowScripts field` on project installs once the field exists. That
+warning is npm's layering at work, not a problem.
+
+Anything npm skips on the global install is reported rather than buried in
+the captured output:
 
 ```
   · Skipped koffi@2.16.3 install script — prebuilt-binary fetcher, the package ships binaries; normally harmless.
@@ -262,7 +304,7 @@ Notes:
 - **Git/GitHub only.** npm publish does not consume git commit messages; `npmchanges.md` lives in the git repo and on GitHub but is excluded from the published npm tarball (the standard `*.md` rule keeps only `README.md`).
 - If both `-m` and `.commitmsg` are present, `-m` wins and `.commitmsg` is left alone (not consumed).
 - If publish fails, `.commitmsg` is preserved for the next attempt.
-- Under `-local` (no publish) the file is still consumed — appended as `## v<version> (local) — <date>` and deleted, with no git commit. See [Local Install](#local-install--local).
+- Under `-local-install` (no publish) the file is still consumed — appended as `## v<version> (local) — <date>` and deleted, with no git commit. See [Local Install](#local-install--local-install).
 - `.commitmsg` is auto-added to `.npmignore` (security pattern) so it never leaks into the tarball.
 
 ### 🔧 Git Integration & Error Recovery
@@ -425,9 +467,11 @@ not what you meant to publish, so npmglobalize lists the conflicted files and st
 ```
 -install, -i    Install globally after publish (from registry)
 -link           Install globally via symlink (npm install -g .)
--local          Local install only — skip transform/publish, just npm install -g .
-                (persisted; a .commitmsg is still logged to npmchanges.md as "(local)")
--global         Clear a persisted -local in .globalize.json5 — back to the normal
+-local-install  Install from the local directory only — skip transform/publish, just
+                npm install -g . with file: deps as-is (also -localinstall; -local is
+                the deprecated old spelling). Persisted; a .commitmsg is still logged
+                to npmchanges.md as "(local)"
+-global         Clear a persisted -local-install in .globalize.json5 — back to the normal
                 transform/publish flow (publishes to npm again)
 -wsl            Also install in WSL
 -once           Don't persist flags to .globalize.json5
@@ -730,6 +774,10 @@ Cycle-safe via a shared visited set; each project is built at most once per run.
 
 This complements the existing publish cascade (which ensures version refs are correct) by closing the build-freshness gap that `npm install` alone left open.
 
+#### `bin` shebang
+
+Every file named in `package.json` `bin` must start with `#!/usr/bin/env node`. npm's Windows `.cmd` shim doesn't care, but the symlink npm creates on Linux, WSL and macOS execs the file directly, and without the shebang `sh` tries to run it and fails with a syntax error. Before each project is built, `npmglobalize` checks each `bin` file and adds the line if it is missing — in the `.ts` source when there is one (tsc carries it through to the emitted `.js`, and the touched source makes the freshness check rebuild), otherwise in the `.js` itself. A leading BOM, which would also defeat the shebang, is removed at the same time. A `bin` entry whose file does not exist yet is reported as a warning.
+
 #### Import maps (`importgen`) as a build step
 
 Browser projects that use [`importgen`](https://www.npmjs.com/package/@bobfrankston/importgen) have historically regenerated their import map from `.vscode/tasks.json`, which only runs when VS Code opens the folder — so a command-line or CI build could publish a stale map. `npmglobalize` treats the import map as a build product and moves the step into the package's own `build` script, where every build path picks it up.
@@ -796,7 +844,7 @@ Both `-flag` and `--flag` are accepted. Single-dash is the primary convention:
 ```bash
 npmglobalize -patch      # same as --patch
 npmglobalize -np         # same as --nopublish
-npmglobalize -local      # same as --local
+npmglobalize -local-install  # same as --local-install
 ```
 
 ### Persistent vs One-Shot Flags
@@ -804,7 +852,7 @@ npmglobalize -local      # same as --local
 Some flags are **persisted** to `.globalize.json5` when set from the CLI:
 - `-install`, `-link`, `-wsl`, `-files`, `-fix` — install/build preferences
 - `-np` (noPublish) — once set, prevents accidental publishes
-- `-local` — remembers "this project is local-only" (clear with `-global`)
+- `-local-install` — remembers "this project is local-only" (clear with `-global`)
 - `-git`/`-npm` visibility
 
 Other flags are **one-shot** (never persisted):
@@ -817,14 +865,14 @@ Use `-once` to prevent any flag from persisting on that run:
 npmglobalize -np -once   # No-publish this run only, don't remember it
 ```
 
-### Local Install (`-local`)
+### Local Install (`-local-install`)
 
 Skip all transform/publish logic and just run `npm install -g .` with `file:` deps as-is. Use this when you want to install a CLI tool locally for your own use without publishing anything:
 
 ```bash
-npmglobalize -local          # Install globally from local directory
-npmglobalize -local -wsl     # Also install in WSL
-npmglobalize -global         # Back to the normal transform/publish flow (publishes to npm)
+npmglobalize -local-install        # Install globally from the local directory
+npmglobalize -local-install -wsl   # Also install in WSL
+npmglobalize -global               # Back to the normal transform/publish flow (publishes to npm)
 ```
 
 This is useful for:
@@ -832,7 +880,11 @@ This is useful for:
 - Testing a CLI before publishing
 - Projects with `file:` deps that should stay as-is
 
-`-local` is persisted to `.globalize.json5` (`"local": true`), so a bare
+`-localinstall` is accepted as well. The old spelling `-local` still works but prints a
+deprecation note; it was renamed (2026-09-07) because "local" read as "local mode" rather
+than "install from the local directory".
+
+`-local-install` is persisted to `.globalize.json5` (`"local": true`), so a bare
 `npmglobalize` keeps doing local installs until you run `-global` (or edit the
 file). Nothing is committed, bumped, or published, but a `.commitmsg` is still
 consumed: it is appended to `npmchanges.md` under a
@@ -879,7 +931,7 @@ npmglobalize -install -wsl
 npmglobalize -link -wsl
 
 # Install locally without publishing (file: deps stay as-is)
-npmglobalize -local
+npmglobalize -local-install
 
 # Restore original file: references
 npmglobalize -cleanup

package/cli.js

@@ -2,7 +2,7 @@
 /**
  * npmglobalize CLI - Transform file: dependencies to npm versions for publishing
  */
-import { globalize, globalizeWorkspace, installCleanupHandlers, readConfig, readPackageJson, readUserNpmConfig, writeConfig, writePackageJson, getBuildIssues, clearBuildIssues, ensureFileDepModules, buildProject, buildFileDepsTopologically, reportTs7Deprecations, fixTs7Deprecations, canonicalCase } from './lib.js';
+import { globalize, globalizeWorkspace, installCleanupHandlers, readConfig, readPackageJson, readUserNpmConfig, writeConfig, writePackageJson, getBuildIssues, clearBuildIssues, ensureFileDepModules, ensureAllowScripts, buildProject, buildFileDepsTopologically, reportTs7Deprecations, fixTs7Deprecations, canonicalCase } from './lib.js';
 import fs from 'fs';
 import path from 'path';
 import { colors } from './colors.js';
@@ -70,9 +70,11 @@ Dependency Options:
 Install Options:
   -install, -i   Global install after publish (from registry)
   -link          Global install via symlink (npm install -g .)
-  -local         Local install only — skip transform/publish, just npm install -g .
-                 (persisted; a .commitmsg is still logged to npmchanges.md as "(local)")
-  -global        Clear a persisted -local in .globalize.json5 — back to the normal
+  -local-install Install from the local directory only — skip transform/publish, just
+                 npm install -g . with file: deps as-is (also -localinstall; -local is
+                 the deprecated old spelling). Persisted; a .commitmsg is still logged
+                 to npmchanges.md as "(local)"
+  -global        Clear a persisted -local-install in .globalize.json5 — back to the normal
                  transform/publish flow (publishes to npm again)
   -wsl           Also install globally in WSL
   -freeze        Freeze node_modules (replace symlinks with real copies for network shares)
@@ -157,8 +159,8 @@ Examples:
   npmglobalize -fix                  Fix security vulnerabilities
   npmglobalize -install -wsl         Release + install on Windows and WSL (from registry)
   npmglobalize -link -wsl            Release + link on Windows and WSL (symlink)
-  npmglobalize -local                Install locally with file: deps as-is (no publish)
-  npmglobalize -local -wsl           Local install on Windows and WSL
+  npmglobalize -local-install        Install from the local directory, file: deps as-is (no publish)
+  npmglobalize -local-install -wsl   Local install on Windows and WSL
   npmglobalize -global               Leave local-only mode; publish to npm from now on
   npmglobalize -np                   Just transform, no publish (remembered in config)
   npmglobalize -cleanup              Restore original dependencies
@@ -228,11 +230,21 @@ function parseArgs(args) {
             case '-cleanup':
                 options.cleanup = true;
                 break;
+            // 2026-09-07 — Claude Code (Fable 5.1), at Bob's direction: "-local is
+            // confusing" — it read like "local mode" / "local deps" rather than "install
+            // from the local directory". Renamed to -local-install (-localinstall also
+            // accepted). -local still works but says so, so muscle memory isn't broken
+            // and the old spelling is phased out rather than silently kept alive.
+            // The .globalize.json5 key stays "local" so existing configs keep working.
             case '-local':
+                console.log(colors.yellow('!  -local is deprecated — use -local-install (same meaning: npm install -g . from the local directory, no publish)'));
+            // falls through
+            case '-local-install':
+            case '-localinstall':
                 options.local = true;
                 options.explicitKeys.add('local');
                 break;
-            // 2026-09-01 16:30 EDT — Claude Code (Opus 5), at Bob's direction. -local
+            // 2026-09-01 16:30 EDT — Claude Code (Opus 5), at Bob's direction. -local-install
             // persists to .globalize.json5 but had no counterpart, so leaving local-only
             // mode meant hand-editing the config. Same shape as -publish for -np.
             // 2026-09-01 15:00 EDT — Bob: "-global makes more sense, -nolocal is confusing";
@@ -609,6 +621,11 @@ export async function main() {
         }
         if (!modulesOk)
             console.log(colors.warn('Continuing with -force despite npm install failure...'));
+        // 2026-09-07 — Claude Code (Fable 5.1), at Bob's direction: keep package.json
+        // "allowScripts" current — own/file: deps approved, third-party ones asked about —
+        // so npm's install-script gate stops warning and the global install honors it.
+        if (modulesOk)
+            await ensureAllowScripts(cwd, { dryRun: !!cliOptions.dryRun, verbose: !!cliOptions.verbose });
         const depsOk = await buildFileDepsTopologically(cwd, { verbose: !!cliOptions.verbose, force: !!cliOptions.force, forceBuild: !!cliOptions.forceBuild });
         if (!depsOk && !cliOptions.force) {
             printBuildSummary();

package/lib.d.ts

@@ -456,6 +456,8 @@ export declare function ensureBuildScript(cwd: string): Promise<{
  *  was skipped because there was nothing to build / the user declined the
  *  build-script prompt / output already up to date). Pass `forceBuild` to
  *  skip the freshness check. */
+/** Every `bin` entry gets a `#!/usr/bin/env node` first line, added to the source if missing. */
+export declare function ensureBinShebang(cwd: string): void;
 export declare function buildProject(cwd: string, opts?: {
     verbose?: boolean;
     force?: boolean;
@@ -559,6 +561,33 @@ export declare function fixPuppeteerCorruptedCache(combined: string): {
  *  Returns [] for an unscoped package: there's no way to tell an unscoped
  *  package of ours from a third-party one by name alone. */
 export declare function ownScopePackages(dir: string): string[];
+/** The project's recorded install-script policy, as registry names. Keys in
+ *  `allowScripts` are `name`, `name@version`, or a `file:` / absolute path;
+ *  path keys are mapped to the target's manifest name so an approval given
+ *  to a linked dep carries over to the global install, where that same dep
+ *  arrives from the registry under its published name. */
+export declare function projectAllowScripts(dir: string): {
+    allowed: string[];
+    denied: string[];
+};
+/** Bring the project's package.json `allowScripts` up to date with what is
+ *  installed, so `npm install` stops warning and — once npm starts enforcing
+ *  the policy — keeps running the scripts this project depends on.
+ *
+ *  Own-scope packages and `file:` deps are approved without asking: they are
+ *  this user's source. Anything else is asked about, one package at a time,
+ *  showing the script npm would run. "no" records a deny (npm's own
+ *  mechanism, `npm deny-scripts`) so the question isn't repeated; "skip"
+ *  leaves it pending for next time. Approvals are name-only
+ *  (`--no-allow-scripts-pin`): a version pin would re-open the question on
+ *  every bump, which is exactly the churn this exists to remove.
+ *
+ *  Runs once per project root, not per cascade dep: npm reads the policy
+ *  from the root package.json only. ~1.5s (arborist loads the actual tree). */
+export declare function ensureAllowScripts(dir: string, opts?: {
+    dryRun?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
 /** Run a command and return success status */
 export declare function runCommand(cmd: string, args: string[], options?: {
     silent?: boolean;

package/lib.js

@@ -332,7 +332,7 @@ const BOOL_COMMENTS = {
     quiet: { on: 'Suppress npm warnings', off: 'Show npm warnings' },
     verbose: { on: 'Show detailed output', off: 'Normal output detail' },
     fix: { on: 'Auto-run npm audit fix (default)', off: 'Do NOT run npm audit fix (audit report still runs)' },
-    local: { on: 'Local install only (skip transform/publish)', off: 'Normal transform/publish flow' },
+    local: { on: 'Local install only via -local-install (skip transform/publish)', off: 'Normal transform/publish flow' },
     noPublish: { on: 'Transform but don\'t publish', off: 'Publish normally' },
     freeze: { on: 'Freeze node_modules (replace symlinks with real copies)', off: 'Leave node_modules symlinks as-is' },
     usePaths: { on: 'Resolve file: deps from sibling checkouts', off: 'Resolve file: deps from npm, not siblings (standalone package)' },
@@ -444,7 +444,7 @@ export function writeConfig(dir, config, explicitKeys) {
         ['"gitVisibility": "private"', 'Git repo: private or public'],
         ['"npmVisibility": "private"', 'npm package: private or public'],
         ['"fix": true', 'true = auto-run npm audit fix (never --force); false = report only'],
-        ['"local": false', 'true = local install only (skip transform/publish); clear with -global'],
+        ['"local": false', 'true = install from the local directory only, set by -local-install (skip transform/publish); clear with -global'],
         ['"noPublish": false', 'true = transform but don\'t publish'],
         ['"freeze": false', 'true = freeze node_modules (replace symlinks with real copies)'],
         ['"usePaths": true', 'true = resolve file: deps from siblings; false = use latest npm version (standalone)'],
@@ -3536,7 +3536,48 @@ export async function ensureBuildScript(cwd) {
  *  was skipped because there was nothing to build / the user declined the
  *  build-script prompt / output already up to date). Pass `forceBuild` to
  *  skip the freshness check. */
+// 2026-09-07 — Claude Code (Fable 5.1), at Bob's direction: "When a program is
+// installed, at least locally, it needs a shebang for node. Make sure the main
+// program has a shebang." npm's Windows .cmd shim doesn't care, but the symlink
+// npm creates on Linux/WSL/macOS execs the file directly, so a bin entry
+// without `#!/usr/bin/env node` fails there with "syntax error" from sh. The
+// shebang belongs in the SOURCE (.ts): tsc carries it through to the emitted
+// .js, and editing the .ts bumps its mtime so the freshness check rebuilds.
+// Runs ahead of the build for that reason, and for every package in the
+// cascade, since a file: dep can be a CLI too.
+/** Every `bin` entry gets a `#!/usr/bin/env node` first line, added to the source if missing. */
+export function ensureBinShebang(cwd) {
+    let pkg;
+    try {
+        pkg = readPackageJson(cwd);
+    }
+    catch {
+        return;
+    } // no package.json: nothing to check, the build reports that
+    if (!pkg?.bin)
+        return;
+    const targets = typeof pkg.bin === 'string' ? [pkg.bin]
+        : (typeof pkg.bin === 'object' ? Object.values(pkg.bin).filter((v) => typeof v === 'string') : []);
+    for (const rel of targets) {
+        const emitted = path.join(cwd, rel);
+        // Prefer the TypeScript source the bin file is emitted from.
+        const tsSibling = emitted.replace(/\.(m|c)?js$/i, '.$1ts');
+        const file = tsSibling !== emitted && fs.existsSync(tsSibling) ? tsSibling : emitted;
+        if (!fs.existsSync(file)) {
+            console.log(colors.yellow(`!  bin "${rel}" in ${pkg.name}: file not found (needs a #!/usr/bin/env node shebang once it exists)`));
+            continue;
+        }
+        const raw = fs.readFileSync(file, 'utf-8');
+        const body = raw.startsWith('') ? raw.slice(1) : raw; // a BOM ahead of #! defeats the shebang
+        if (body.startsWith('#!'))
+            continue;
+        fs.writeFileSync(file, `#!/usr/bin/env node
+${body}`, 'utf-8');
+        console.log(colors.green(`+ Added #!/usr/bin/env node to ${path.relative(cwd, file)} (bin "${rel}")`));
+    }
+}
 export async function buildProject(cwd, opts = {}) {
+    ensureBinShebang(cwd);
     // Fix removed-in-TS7 tsconfig settings up front rather than waiting for a
     // build to fail on them. A deprecated `moduleResolution` is only a *hard*
     // error under the tsc that flags it (TS6+, and the editor's bundled
@@ -4214,20 +4255,238 @@ export function ownScopePackages(dir) {
     walk(pkg, dir);
     return [...found];
 }
-/** npm args allowing install scripts for our own packages only. Empty when
- *  npm predates the policy (it runs the scripts anyway) or the package is
- *  unscoped.
- *
- *  Note: the CLI layer *replaces* the .npmrc layer rather than merging with
- *  it (first source with any config wins, per npm's resolve-allow-scripts),
- *  so passing this suppresses any allow-scripts entries in .npmrc for this
- *  install. Third-party approvals therefore belong on the command line too,
- *  not in .npmrc. */
-function allowOwnScriptsArgs(dir) {
+// 2026-09-07 — Claude Code (Fable 5.1), at Bob's direction ("I want you to handle
+// this", after `npm un itemgen` in whts warned about com-wrapper, msger and sharp).
+// The project side of the policy. npm REJECTS `--allow-scripts` on a project-scoped
+// install (EALLOWSCRIPTS), so the only place a project's approvals can live is the
+// `allowScripts` field of its package.json, maintained by `npm approve-scripts`.
+// npmglobalize now keeps that field current (ensureAllowScripts) and feeds it back
+// into the global install's `--allow-scripts` flag (allowScriptsArgs), so a package
+// is trusted once, in one place, for both kinds of install.
+/** Names of the project's `file:` dependencies as npm displays them in the
+ *  allowScripts pending list. A linked dep has no registry identity, so npm
+ *  falls back to the link target's directory name (`com-wrapper` for
+ *  `@bobfrankston/com-wrapper` at ../../projects/com/com-wrapper); the
+ *  manifest name is included too in case that fallback ever changes. */
+function localDepDisplayNames(dir) {
+    let pkg;
+    try {
+        pkg = readPackageJson(dir);
+    }
+    catch {
+        return [];
+    }
+    const names = [];
+    for (const key of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+        const deps = pkg[key];
+        if (!deps || typeof deps !== 'object')
+            continue;
+        for (const spec of Object.values(deps)) {
+            if (typeof spec !== 'string' || !spec.startsWith('file:'))
+                continue;
+            const target = path.resolve(dir, spec.slice('file:'.length));
+            names.push(path.basename(target));
+            try {
+                const name = readPackageJson(target).name;
+                if (name)
+                    names.push(name);
+            }
+            catch { /* target missing or unreadable — the basename alone still identifies it */ }
+        }
+    }
+    return names;
+}
+/** The project's recorded install-script policy, as registry names. Keys in
+ *  `allowScripts` are `name`, `name@version`, or a `file:` / absolute path;
+ *  path keys are mapped to the target's manifest name so an approval given
+ *  to a linked dep carries over to the global install, where that same dep
+ *  arrives from the registry under its published name. */
+export function projectAllowScripts(dir) {
+    const allowed = [];
+    const denied = [];
+    let pkg;
+    try {
+        pkg = readPackageJson(dir);
+    }
+    catch {
+        return { allowed, denied };
+    }
+    const policy = pkg.allowScripts;
+    if (!policy || typeof policy !== 'object')
+        return { allowed, denied };
+    // A `file:` key written by `npm approve-scripts` is the link's saved spec,
+    // which npm records relative to the LINK's parent directory — verified on
+    // whts: package.json says `file:../../projects/com/com-wrapper`, the policy
+    // key came out `file:../../../../projects/com/com-wrapper`, i.e. relative to
+    // node_modules/@bobfrankston/. A hand-written key is relative to the
+    // project. Try both bases.
+    const bases = new Set([dir]);
+    for (const key of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+        for (const [name, spec] of Object.entries(pkg[key] || {})) {
+            if (typeof spec === 'string' && spec.startsWith('file:'))
+                bases.add(path.dirname(path.join(dir, 'node_modules', name)));
+        }
+    }
+    const manifestName = (rel) => {
+        for (const base of bases) {
+            try {
+                return readPackageJson(path.resolve(base, rel)).name;
+            }
+            catch { /* not this base — try the next; the caller skips the key when none has it */ }
+        }
+        return null;
+    };
+    for (const [key, value] of Object.entries(policy)) {
+        let name;
+        if (key.startsWith('file:') || path.isAbsolute(key)) {
+            name = manifestName(key.startsWith('file:') ? key.slice('file:'.length) : key);
+        }
+        else {
+            // strip a trailing @version; a scoped name keeps its leading @
+            name = key.replace(/(.)@[^@]*$/, '$1');
+        }
+        if (!name)
+            continue;
+        (value === false ? denied : allowed).push(name);
+    }
+    return { allowed, denied };
+}
+/** Names from the user's own `allow-scripts` npm config (.npmrc layers).
+ *  npm's resolver takes the FIRST layer with any config and ignores the
+ *  rest, so a CLI flag would silently suppress these — merging them into the
+ *  flag keeps `npm config set allow-scripts=… --location=user` meaningful. */
+function npmrcAllowScripts() {
+    const r = runCommand('npm', ['config', 'get', 'allow-scripts'], { silent: true });
+    if (!r.success || isUnknownConfig(r.output))
+        return [];
+    return r.output.split(/[,\s]+/).map(s => s.trim()).filter(Boolean);
+}
+/** npm args allowing install scripts on a GLOBAL install: our own packages,
+ *  whatever the project's package.json `allowScripts` approves, and the
+ *  user's .npmrc list — minus anything the project denies. Empty when npm
+ *  predates the policy (it runs the scripts anyway) or nothing is allowed. */
+function allowScriptsArgs(dir) {
     if (!npmSupportsAllowScripts())
         return [];
-    const own = ownScopePackages(dir);
-    return own.length ? ['--allow-scripts', own.join(',')] : [];
+    const project = projectAllowScripts(dir);
+    const names = [...new Set([...ownScopePackages(dir), ...project.allowed, ...npmrcAllowScripts()])]
+        .filter(n => !project.denied.includes(n));
+    return names.length ? ['--allow-scripts', names.join(',')] : [];
+}
+/** Parse the text listing of `npm approve-scripts --allow-scripts-pending`:
+ *  one indented `name@version (event: cmd; event: cmd)` line per node,
+ *  the same package repeated when several versions are installed. */
+function parsePendingScripts(output) {
+    const byName = new Map();
+    for (const line of output.split('\n')) {
+        const m = line.match(/^  (\S+?)(?:@([^@\s]+))? \((.*)\)\s*$/);
+        if (!m)
+            continue;
+        const [, name, version, scripts] = m;
+        const entry = byName.get(name) ?? { name, versions: [], scripts };
+        if (version)
+            entry.versions.push(version);
+        byName.set(name, entry);
+    }
+    return [...byName.values()];
+}
+/** Bring the project's package.json `allowScripts` up to date with what is
+ *  installed, so `npm install` stops warning and — once npm starts enforcing
+ *  the policy — keeps running the scripts this project depends on.
+ *
+ *  Own-scope packages and `file:` deps are approved without asking: they are
+ *  this user's source. Anything else is asked about, one package at a time,
+ *  showing the script npm would run. "no" records a deny (npm's own
+ *  mechanism, `npm deny-scripts`) so the question isn't repeated; "skip"
+ *  leaves it pending for next time. Approvals are name-only
+ *  (`--no-allow-scripts-pin`): a version pin would re-open the question on
+ *  every bump, which is exactly the churn this exists to remove.
+ *
+ *  Runs once per project root, not per cascade dep: npm reads the policy
+ *  from the root package.json only. ~1.5s (arborist loads the actual tree). */
+export async function ensureAllowScripts(dir, opts = {}) {
+    if (!npmSupportsAllowScripts())
+        return;
+    let pkgName;
+    try {
+        pkgName = readPackageJson(dir).name;
+    }
+    catch {
+        return;
+    }
+    const listing = await runCommandAsync('npm', ['approve-scripts', '--allow-scripts-pending'], { cwd: dir, silent: true });
+    if (!listing.success) {
+        if (opts.verbose)
+            console.log(colors.dim(`  (could not list pending install scripts in ${pkgName}: ${(listing.stderr || listing.output).trim().split('\n')[0]})`));
+        return;
+    }
+    const pending = parsePendingScripts(listing.output);
+    if (!pending.length)
+        return;
+    const trusted = new Set([...ownScopePackages(dir), ...localDepDisplayNames(dir)]);
+    const auto = pending.filter(p => trusted.has(p.name));
+    const ask = pending.filter(p => !trusted.has(p.name));
+    const label = (p) => p.versions.length ? `${p.name}@${p.versions.join('|')}` : p.name;
+    if (opts.dryRun) {
+        console.log(colors.dim(`  [dry-run] allowScripts in ${pkgName}: would approve ${auto.map(label).join(', ') || '(none)'}; would ask about ${ask.map(label).join(', ') || '(none)'}`));
+        return;
+    }
+    const approve = auto.map(p => p.name);
+    const deny = [];
+    const skipped = [];
+    if (ask.length) {
+        if (!process.stdin.isTTY) {
+            console.log(colors.yellow(`  ⚠ ${ask.length} third-party package(s) in ${pkgName} have install scripts not yet covered by allowScripts (no terminal to ask): ${ask.map(label).join(', ')}`));
+            console.log(colors.dim(`    npm approve-scripts --no-allow-scripts-pin <pkg>   or   npm deny-scripts <pkg>`));
+            skipped.push(...ask.map(label));
+        }
+        else {
+            console.log(colors.cyan(`npm gates install scripts for ${ask.length} third-party package(s) in ${pkgName}. Approvals are recorded in package.json "allowScripts" (name-only) and honored on the global install too.`));
+            let allRemaining = false;
+            for (const p of ask) {
+                const prebuilt = PREBUILT_SCRIPT_RUNNERS.test(p.scripts) ? ' — prebuilt-binary fetcher, the package ships binaries' : '';
+                if (allRemaining) {
+                    approve.push(p.name);
+                    continue;
+                }
+                const answer = await promptChoice(`  Allow install scripts for ${label(p)} (${p.scripts})${prebuilt}?  [y]es / [n]o, deny / [a]ll remaining / [s]kip for now:`, ['y', 'n', 'a', 's']);
+                switch (answer) {
+                    case 'y':
+                        approve.push(p.name);
+                        break;
+                    case 'a':
+                        approve.push(p.name);
+                        allRemaining = true;
+                        break;
+                    case 'n':
+                        deny.push(p.name);
+                        break;
+                    default:
+                        skipped.push(label(p));
+                        break; // 's', or EOF ('' from promptChoice)
+                }
+            }
+        }
+    }
+    // `npm approve-scripts <name>` matches installed nodes by the same display
+    // name the pending listing used, and writes the right key for each kind
+    // (registry name, or the file: path for a linked dep).
+    if (approve.length) {
+        const r = await runCommandAsync('npm', ['approve-scripts', '--no-allow-scripts-pin', ...approve], { cwd: dir, silent: true });
+        if (r.success)
+            console.log(colors.green(`  ✓ allowScripts: approved ${approve.join(', ')}${auto.length ? ` (${auto.length} own/local approved automatically)` : ''}`));
+        else
+            console.log(colors.red(`  ✗ npm approve-scripts failed: ${(r.stderr || r.output).trim().split('\n').find(l => /npm error/.test(l)) ?? 'see output'}`));
+    }
+    if (deny.length) {
+        const r = await runCommandAsync('npm', ['deny-scripts', ...deny], { cwd: dir, silent: true });
+        if (r.success)
+            console.log(colors.yellow(`  ✓ allowScripts: denied ${deny.join(', ')} (remove the entry from package.json allowScripts to reconsider)`));
+        else
+            console.log(colors.red(`  ✗ npm deny-scripts failed: ${(r.stderr || r.output).trim().split('\n').find(l => /npm error/.test(l)) ?? 'see output'}`));
+    }
+    if (skipped.length)
+        console.log(colors.dim(`  · install scripts still unreviewed (asked again next run): ${skipped.join(', ')}`));
 }
 /** Install-script runners that fetch or select a prebuilt binary and only
  *  compile when no prebuild matches the platform. A package using one of these
@@ -4301,9 +4560,10 @@ async function installGlobalWithRetry(pkgSpec, cwd, isNewPackage = false, maxRet
     let attempt = 0;
     let cacheFixRounds = 0;
     // Our own packages are trusted — we just built and published them from
-    // this very directory — so their install scripts run. Everything else
-    // stays behind npm's allowScripts gate.
-    const allowArgs = allowOwnScriptsArgs(cwd);
+    // this very directory — so their install scripts run, along with whatever
+    // the project's package.json allowScripts approved (ensureAllowScripts)
+    // and the user's .npmrc list. Everything else stays behind npm's gate.
+    const allowArgs = allowScriptsArgs(cwd);
     while (true) {
         // 2026-09-01 10:15 EDT — Claude Code (Opus 5), at Bob's direction.
         // `--prefer-online`: this install always targets a version published
@@ -4623,13 +4883,15 @@ async function verifyWslGlobalBins(cwd) {
     }
 }
 export async function installInWsl(wslArgs, opts = {}) {
-    // Same trust rule as the Windows installs: allow our own packages'
-    // install scripts, leave third-party ones gated. Probed against WSL's
+    // Same trust rule as the Windows installs: our own packages plus the
+    // project's package.json approvals, minus its denies. The Windows .npmrc
+    // list is left out — WSL's npm has its own .npmrc. Probed against WSL's
     // npm, which is a separate install from the Windows one.
     if (opts.cwd && wslArgs.includes('install') && await wslNpmSupportsAllowScripts()) {
-        const own = ownScopePackages(opts.cwd);
-        if (own.length)
-            wslArgs = [...wslArgs, '--allow-scripts', own.join(',')];
+        const project = projectAllowScripts(opts.cwd);
+        const names = [...new Set([...ownScopePackages(opts.cwd), ...project.allowed])].filter(n => !project.denied.includes(n));
+        if (names.length)
+            wslArgs = [...wslArgs, '--allow-scripts', names.join(',')];
     }
     const runOnce = async () => {
         console.log(colors.cyan(`> wsl ${wslArgs.join(' ')}`));
@@ -6308,15 +6570,15 @@ export function getToolVersion() {
     }
 }
 // 2026-09-01 16:30 EDT — Claude Code (Opus 5), at Bob's direction.
-// Under -local the run returned before any of the .commitmsg handling, so the
+// Under -local-install the run returned before any of the .commitmsg handling, so the
 // notes a local-only package accumulated in .commitmsg were never recorded
 // anywhere — they sat in the file, and the next edit overwrote them. A local
 // install is still a change worth a history line, so the same npmchanges.md
 // gets the entry, tagged "(local)" because nothing was published or bumped
 // (several local runs may legitimately share one version number). No git
-// activity: -local is the path taken when there is often no repo at all, and
+// activity: -local-install is the path taken when there is often no repo at all, and
 // when there is one the next real publish commits npmchanges.md with the rest.
-/** Consume .commitmsg for a -local run: append to npmchanges.md, delete the file. */
+/** Consume .commitmsg for a -local-install run: append to npmchanges.md, delete the file. */
 function recordLocalChange(cwd, version, dryRun) {
     const commitMsgPath = path.join(cwd, '.commitmsg');
     if (!fs.existsSync(commitMsgPath))
@@ -6351,8 +6613,8 @@ function recordLocalChange(cwd, version, dryRun) {
         console.error(colors.yellow(`  Warning: could not update npmchanges.md: ${err.message}`));
     }
 }
-/** Perform local-only install (npm install -g .) — the single -local path, reached
- *  from the -local flag / config and from the git-init prompts' "local only" choice. */
+/** Perform local-only install (npm install -g .) — the single -local-install path, reached
+ *  from the -local-install flag / config and from the git-init prompts' "local only" choice. */
 async function doLocalInstall(cwd, options) {
     const { dryRun = false, wsl = false } = options;
     const pkg = readPackageJson(cwd);
@@ -6472,7 +6734,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         if (configOptions.show)
             settings.push('--show');
         if (configOptions.local)
-            settings.push('-local');
+            settings.push('-local-install');
         if (configOptions.freeze)
             settings.push('-freeze');
         if (configOptions.usePaths === false)
@@ -6489,8 +6751,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         }
     }
     console.log('');
-    // -local: skip all transform/publish, just install from local directory with file: deps intact.
-    // -local is testing-only and must NOT mutate package.json — packages are meant to be installed
+    // -local-install: skip all transform/publish, just install from local directory with file: deps intact.
+    // -local-install is testing-only and must NOT mutate package.json — packages are meant to be installed
     // as published public packages by end users; the bin field is whatever the published shape is.
     // Library members (no bin) are silently skipped: nothing for global install to expose.
     // 2026-09-01 16:30 EDT — Claude Code (Opus 5): this was a verbatim copy of
@@ -6922,6 +7184,10 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         }
         if (!modulesOk)
             console.log(colors.yellow('Continuing with -force despite npm install failure...'));
+        // 2026-09-07 — Claude Code (Fable 5.1): same allowScripts upkeep the CLI
+        // entrypoint does; the global install below reads the result.
+        if (modulesOk)
+            await ensureAllowScripts(cwd, { verbose });
     }
     // Run build step if package.json has a build script (skip if CLI already built)
     if (pkg.scripts?.build && !options._fromCli) {
@@ -8792,7 +9058,7 @@ export async function globalizeWorkspace(rootDir, options = {}, configOptions =
     console.log(`Packages (${packages.length}): ${packages.map(p => p.name).join(', ')}`);
     console.log(`Publish order: ${publishOrder.join(' → ')}`);
     console.log('');
-    // Warn if -local / -install are present at the workspace root: those are
+    // Warn if -local-install / -install are present at the workspace root: those are
     // component-level concerns. In workspace mode they only act on members
     // that have a `bin` field; libraries are silently skipped. Telling the
     // user up front avoids the surprise of "I asked for install but most
@@ -8800,7 +9066,7 @@ export async function globalizeWorkspace(rootDir, options = {}, configOptions =
     const installSources = [];
     if (options.local || configOptions.local) {
         const src = configOptions.local && !options.local ? '.globalize.json5' : 'CLI';
-        installSources.push(`-local (${src})`);
+        installSources.push(`-local-install (${src})`);
     }
     if (options.install || configOptions.install) {
         const src = configOptions.install && !options.install ? '.globalize.json5' : 'CLI';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.220",
+  "version": "1.0.222",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@bobfrankston/freezepak": "^0.1.9",
-    "@bobfrankston/importgen": "^0.1.40",
+    "@bobfrankston/importgen": "^0.1.43",
     "@bobfrankston/themecolors": "^0.1.9",
     "@bobfrankston/userconfig": "^1.0.11",
     "@npmcli/package-json": "^7.0.4",
@@ -60,7 +60,7 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/freezepak": "^0.1.9",
-      "@bobfrankston/importgen": "^0.1.40",
+      "@bobfrankston/importgen": "^0.1.43",
       "@bobfrankston/themecolors": "^0.1.9",
       "@bobfrankston/userconfig": "^1.0.11",
       "@npmcli/package-json": "^7.0.4",