@event4u/agent-config 9.7.0 → 9.9.0

package/src/scripts/hooks/rtk_wrap_hook.ts

@@ -4,10 +4,13 @@
  * (token-saving Phase 3).
  *
  * Converts RTK from advisory to DETERMINISTIC: instead of trusting a
- * self-reported flag, this hook keys off a live `which rtk` probe. When rtk is
- * actually installed AND the agent is about to run a single verbose CLI command
- * that is NOT completeness-critical, it surfaces (warn) "re-run wrapped with
- * rtk" so the 60–90% output-token saving is captured. It NEVER blocks (the v1
+ * self-reported flag, this hook keys off a live probe — PATH presence PLUS an
+ * `rtk gain` identity check (the binary name collides with the unrelated Rust
+ * Type Kit; see src/install/rtkDetection.ts). When a VERIFIED Rust Token
+ * Killer is installed AND the agent is about to run a single verbose CLI
+ * command that is NOT completeness-critical, it surfaces (warn) "re-run
+ * wrapped with rtk" so the upstream-reported 60–90% output-token saving is
+ * captured. It NEVER blocks (the v1
  * dispatcher contract is allow/block/warn — there is no transparent
  * `updatedInput` rewrite — and, like `injection_scan_hook`, warn preserves
  * agency). It NEVER fires when rtk is absent (silent plain-command fallback,
@@ -35,6 +38,8 @@ import {
   _split_subcommands,
   _is_env_assignment,
 } from "./block_no_verify.js";
+import { readHookStdin } from "./hook_stdin.js";
+import { detectRtkCached } from "../../install/rtkDetection.js";
 
 const SETTINGS_FILE = ".agent-settings.yml";
 const EXIT_ALLOW = 0;
@@ -171,12 +176,7 @@ export function classify(command: string): Eligibility {
 }
 
 function _readStdin(): string {
-  try {
-    if (process.stdin.isTTY) return "";
-    return fs.readFileSync(0, "utf-8");
-  } catch {
-    return "";
-  }
+  return readHookStdin();
 }
 
 function _jsonReason(reason: string): string {
@@ -203,8 +203,16 @@ export function main(): number {
         : ".";
   if (!_enabled(root)) return EXIT_ALLOW;
 
-  // Deterministic gate: the live probe, NOT a self-reported flag.
+  // Deterministic gate: the live probe, NOT a self-reported flag — and an
+  // IDENTITY probe, not bare presence: the `rtk` binary name collides with
+  // the unrelated Rust Type Kit, and nudging the agent to wrap commands with
+  // the wrong tool would be a second wrong answer. Only a verified Rust
+  // Token Killer activates the nudge; `unverified` (broken/slow probe) does
+  // NOT — fail closed for behavior, fail open for the command itself.
+  // Identity is cached user-globally keyed on the binary's path+mtime+size,
+  // so the `rtk gain` probe runs once per installed binary, not per command.
   if (!rtk_available()) return EXIT_ALLOW;
+  if (detectRtkCached().identity !== "token-killer") return EXIT_ALLOW;
 
   const command = _extract_command(envelope);
   if (!command) return EXIT_ALLOW;
@@ -213,14 +221,20 @@ export function main(): number {
   if (!verdict.eligible) return EXIT_ALLOW;
 
   const reason =
-    `rtk is installed and wraps verbose CLI output (60–90% fewer output tokens). ` +
+    `rtk is installed and wraps verbose CLI output (upstream reports 60–90% fewer output tokens). ` +
     `Re-run wrapped: \`rtk ${command.trim()}\`. ` +
     `(Skip for completeness-critical output like \`git diff\`.)`;
   process.stdout.write(`${_jsonReason(reason)}\n`);
   return EXIT_WARN;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/hot_context_hook.ts

@@ -37,6 +37,7 @@ import { fileURLToPath } from 'node:url';
 
 import { hardenedSpawnEnv } from './_lib/spawn_env.js';
 import { redact_low_impact_entry } from './ai_council/redact_low_impact_entry.js';
+import { readHookStdin } from './hooks/hook_stdin.js';
 
 export const HOT_CONTEXT_REL = path.join('agents', 'runtime', 'state', 'hot-context.md');
 
@@ -350,11 +351,7 @@ function _session_index_block_or_null(root: string): string | null {
 // ---------------------------------------------------------------------
 
 function _read_stdin(): string {
-    try {
-        return fs.readFileSync(0, 'utf-8');
-    } catch {
-        return '';
-    }
+    return readHookStdin();
 }
 
 export function main(): number {
@@ -414,6 +411,10 @@ export function main(): number {
     return 0; // never blocks
 }
 
-if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+const _bundled = typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__;
+if (!_bundled && fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
     process.exit(main());
 }

package/src/scripts/injection_scan_hook.ts

@@ -30,6 +30,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+import { readHookStdin } from "./hooks/hook_stdin.js";
+
 const SETTINGS_FILE = ".agent-settings.yml";
 const EXIT_ALLOW = 0;
 const EXIT_WARN = 2;
@@ -274,10 +276,16 @@ function _pyTruthy(v: JsonValue | undefined): boolean {
 }
 
 function _readStdin(): string {
-  return fs.readFileSync(0, "utf-8");
+  return readHookStdin();
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/install

@@ -3,7 +3,7 @@
 #
 # Orchestrates the two stages:
 #   1. scripts/install.sh  — payload sync (copy rules, symlink skills/commands)
-#   2. scripts/install.py  — bridge files (.agent-settings, VSCode/Augment JSONs)
+#   2. scripts/install.ts  — bridge files (.agent-settings, VSCode/Augment JSONs)
 #
 # This is the only installer a consumer needs to invoke. The underlying
 # scripts remain callable directly for advanced use; see their --help.
@@ -35,7 +35,7 @@
 #   --verbose         Detailed payload sync output
 #   --quiet           Suppress non-error output
 #   --skip-sync       Skip payload sync (install.sh)
-#   --skip-bridges    Skip bridge files (install.py)
+#   --skip-bridges    Skip bridge files (install.ts)
 #   --global          Install to user-scope paths (~/.claude/, ~/.cursor/, …)
 #                     instead of project-locally. Implies --skip-sync (the
 #                     payload sync stage is project-only). See ADR-007.
@@ -100,7 +100,7 @@ FLEET_CONFIG=""
 USER_TYPE=""
 NO_UI=false
 
-# Single source of truth for valid tool IDs (also referenced by install.sh / install.py).
+# Single source of truth for valid tool IDs (also referenced by install.sh / install.ts).
 VALID_TOOLS="claude-code claude-desktop cursor windsurf cline gemini-cli copilot augment aider codex roocode continue kilocode zed jetbrains kiro all"
 
 show_help() {
@@ -214,9 +214,9 @@ fi
 # (and its --scope project / --scope=project / SCOPE shorthand) is the
 # maintainer-only escape hatch behind AGENT_CONFIG_DEV_MODE=1. Without
 # the env flag we refuse here so the bash orchestrator fails fast with
-# a directive error pointing at the maintainer doc — install.py's
+# a directive error pointing at the maintainer doc — install.ts's
 # Python-side _enforce_consumer_global_only still backstops the same
-# check for direct python3 scripts/install.py invocations.
+# check for legacy direct python3 installer invocations (retired install.py).
 if [[ "${SCOPE:-}" == "project" && "${AGENT_CONFIG_DEV_MODE:-}" != "1" ]]; then
     err "--scope=project is reserved for maintainers (ADR-020 — consumer installs are global-only). Set AGENT_CONFIG_DEV_MODE=1 to opt in. See docs/maintainers/dev-mode.md."
     exit 1
@@ -296,7 +296,7 @@ prompt_tools() {
 # When an interactive global install will hand off to the browser wizard,
 # the wizard is the single tool-selection surface — skip the terminal
 # picker so it does not pre-empt (and, via TOOLS_EXPLICIT, suppress) the
-# GUI. Mirrors install.py::_wizard_should_launch (the --no-ui flag is
+# GUI. Mirrors install.ts wizard_should_launch (the --no-ui flag is
 # handled here too — it suppresses both the wizard and the picker).
 # Headless paths (no TTY / CI / AGENT_CONFIG_NO_UI) still get the picker.
 wizard_will_handle_tools=false

package/src/scripts/install-hooks.sh

@@ -91,7 +91,7 @@ fi
 EOF
 
 chmod +x "$HOOKS_DIR/pre-push"
-echo "✅  Pre-push hook installed."
+echo "✅  Pre-push hook installed." >&2
 
 # Pre-commit: marketplace consistency -----------------------------------------
 #
@@ -184,7 +184,7 @@ fi
 EOF
 
 chmod +x "$HOOKS_DIR/pre-commit"
-echo "✅  Pre-commit hook installed."
+echo "✅  Pre-commit hook installed." >&2
 
 # Chat-history bridge hooks ----------------------------------------------------
 #
@@ -218,7 +218,7 @@ fi
 # command above is guarded by "|| true", so the implicit exit is 0.
 EOF
     chmod +x "$HOOKS_DIR/$name"
-    echo "✅  $name hook installed."
+    echo "✅  $name hook installed." >&2
 }
 
 write_chat_history_hook "post-commit"   "git:post-commit"
@@ -275,4 +275,4 @@ EOF
 
 append_auto_sync_block "post-merge"    "1"
 append_auto_sync_block "post-checkout" "3"
-echo "✅  Auto-sync block appended to post-merge / post-checkout hooks."
+echo "✅  Auto-sync block appended to post-merge / post-checkout hooks." >&2

package/src/scripts/install.sh

@@ -8,7 +8,8 @@
 # Creates tool-specific directories for Claude Code, Cursor, Cline, Windsurf, Gemini.
 #
 # Does NOT render .agent-settings.yml or bridge JSONs — that is the job of
-# scripts/install.py. The primary entry point scripts/install orchestrates both.
+# scripts/install.ts (run via the bundled dist/install/install.mjs). The
+# primary entry point scripts/install orchestrates both.
 # Running this script on its own installs the payload only.
 #
 # Usage:
@@ -50,7 +51,7 @@ SKIP_GITIGNORE=false
 # that require both channels.
 LEGACY_BOTH=false
 # When true, skip payload sync entirely and only install the project-local
-# `./agent-config` wrapper (Step 7 Phase 2). The bridge stage (install.py)
+# `./agent-config` wrapper (Step 7 Phase 2). The bridge stage (install.ts)
 # handles the .agent-settings.yml stub + nested-install guard.
 MINIMAL=false
 # Comma-separated tool IDs (default: all). Set by --tools or the
@@ -91,7 +92,7 @@ parse_args() {
             --skip-gitignore) SKIP_GITIGNORE=true; shift ;;
             --tools)   TOOLS="$2"; shift 2 ;;
             --tools=*) TOOLS="${1#*=}"; shift ;;
-            # --user-type is consumed by install.py (settings persistence).
+            # --user-type is consumed by install.ts (settings persistence).
             # Accepted here so direct `bash scripts/install.sh --user-type=...`
             # invocations from the `install` wrapper / standalone users do not
             # trip the "Unknown argument" guard. Value is intentionally unused
@@ -1171,7 +1172,7 @@ main() {
 
     # Minimal-init short-circuit (Step 7 Phase 2): skip every payload-sync
     # stage and only install the project-local `./agent-config` wrapper.
-    # The bridge stage (install.py) handles the .agent-settings.yml stub
+    # The bridge stage (install.ts) handles the .agent-settings.yml stub
     # + nested-install guard. No .augment/, no AGENTS.md, no symlinks.
     if $MINIMAL; then
         if ! $QUIET; then

package/src/scripts/install.ts

@@ -77,6 +77,7 @@ import * as installed_lock from './_lib/installed_lock.js';
 import * as surface_tiers from './_lib/surface_tiers.js';
 import * as global_deploy_inventory from './_lib/global_deploy_inventory.js';
 import * as installed_tools from './_lib/installed_tools.js';
+import { collect_drift, format_drift_report } from './_lib/install_drift.js';
 import * as user_global_paths from './_lib/user_global_paths.js';
 import * as claude_desktop_bundler from './_lib/claude_desktop_bundler.js';
 import * as claude_settings_hooks from './_lib/claude_settings_hooks.js';
@@ -2892,7 +2893,11 @@ export function _apply_claude_flat_command_wrappers(
         current_files.delete(`commands/${fname}`);
         reserved.push(slug);
     }
-    // Tier-0/1 visible command slugs from the locked discovery manifest.
+    // Visible command slugs from the locked discovery manifest. `visibility`
+    // is the source of truth (ADR-090/092); the integer `tier` stays only as
+    // the fallback for a manifest published before `visibility` was emitted,
+    // so an older locked manifest keeps resolving. Neither key present → the
+    // artefact is skipped rather than silently treated as visible.
     const eligible = new Set<string>(_CLAUDE_FLAT_WRAPPER_EXTRA);
     try {
         const manifest = JSON.parse(
@@ -2900,7 +2905,13 @@ export function _apply_claude_flat_command_wrappers(
         ) as { artefacts?: Array<{ category?: string; slug?: string; tier?: number; visibility?: string }> };
         for (const a of manifest.artefacts ?? []) {
             if (a.category !== 'command' || typeof a.slug !== 'string') continue;
-            if ((a.tier ?? 2) <= 1 && a.visibility !== 'internal') eligible.add(a.slug);
+            const visible =
+                typeof a.visibility === 'string'
+                    ? a.visibility !== 'internal'
+                    : typeof a.tier === 'number'
+                      ? a.tier <= 1
+                      : false;
+            if (visible) eligible.add(a.slug);
         }
     } catch {
         // No manifest → wrap only the hardcoded essentials.
@@ -3136,34 +3147,36 @@ function _verify_deploy_targets(anchor: string, plan: ReadonlyArray<readonly [st
 }
 
 /**
- * Remove lab-tier skills/commands from a completed deploy (core-only).
+ * Remove skills/commands matching `is_pruned` from a completed deploy.
  *
- * road-to-install-contract-stability Phase 2 Step 2. Skills are pruned by
- * whole directory (tier decided by the skill's `SKILL.md` frontmatter);
- * commands by file (own frontmatter). Rules / personas / contexts / templates
- * are core/shared and left intact. Returns `[pruned_count, adjusted_results]`
- * with the lab paths removed from each tool's `written_paths` so the manifest
- * never records them.
+ * road-to-install-contract-stability Phase 2 Step 2 (generalized in
+ * road-to-credible-install Phase 2 to back both the core-only lab prune and
+ * the scoped-projection pack prune off the same mechanics). Skills are
+ * pruned by whole directory (tier decided by the skill's `SKILL.md`
+ * frontmatter); commands by file (own frontmatter). Rules / personas /
+ * contexts / templates are core/shared and left intact. Returns
+ * `[pruned_count, adjusted_results]` with the pruned paths removed from each
+ * tool's `written_paths` so the manifest never records them.
  */
-function _prune_lab_modules(
+function _prune_modules_by(
     deploy_results: Record<string, DeployResult>,
-    lab_ids: Set<string>,
+    is_pruned: (md_path: string) => boolean,
 ): [number, Record<string, DeployResult>] {
     let pruned = 0;
     const adjusted: Record<string, DeployResult> = {};
     for (const tool_id of Object.keys(deploy_results)) {
         const [written, skipped, status, paths] = deploy_results[tool_id] as DeployResult;
-        const lab_skill_dirs = new Set<string>();
+        const pruned_skill_dirs = new Set<string>();
         for (const p of paths) {
             const parts = p.split(path.sep);
             if (parts.includes('skills')) {
                 const i = parts.indexOf('skills');
                 if (i + 1 < parts.length) {
                     const skill_root = parts.slice(0, i + 2).join(path.sep);
-                    if (!lab_skill_dirs.has(skill_root)) {
+                    if (!pruned_skill_dirs.has(skill_root)) {
                         const skillmd = path.join(skill_root, 'SKILL.md');
-                        if (pathExists(skillmd) && surface_tiers.is_lab_artefact(skillmd, lab_ids)) {
-                            lab_skill_dirs.add(skill_root);
+                        if (pathExists(skillmd) && is_pruned(skillmd)) {
+                            pruned_skill_dirs.add(skill_root);
                         }
                     }
                 }
@@ -3173,22 +3186,22 @@ function _prune_lab_modules(
         const delete_files: string[] = [];
         for (const p of paths) {
             const parts = p.split(path.sep);
-            let is_lab = false;
+            let is_target = false;
             if (parts.includes('skills')) {
                 const i = parts.indexOf('skills');
-                if (i + 1 < parts.length && lab_skill_dirs.has(parts.slice(0, i + 2).join(path.sep))) {
-                    is_lab = true;
+                if (i + 1 < parts.length && pruned_skill_dirs.has(parts.slice(0, i + 2).join(path.sep))) {
+                    is_target = true;
                 }
             } else if (
                 parts.includes('commands') &&
                 path.extname(p) === '.md' &&
-                surface_tiers.is_lab_artefact(p, lab_ids)
+                is_pruned(p)
             ) {
-                is_lab = true;
+                is_target = true;
             }
-            (is_lab ? delete_files : keep).push(p);
+            (is_target ? delete_files : keep).push(p);
         }
-        for (const d of lab_skill_dirs) {
+        for (const d of pruned_skill_dirs) {
             fs.rmSync(d, { recursive: true, force: true });
         }
         for (const p of delete_files) {
@@ -3206,6 +3219,175 @@ function _prune_lab_modules(
     return [pruned, adjusted];
 }
 
+/**
+ * Remove lab-tier skills/commands from a completed deploy (core-only).
+ *
+ * road-to-install-contract-stability Phase 2 Step 2. Thin wrapper over
+ * `_prune_modules_by` — see that function for the mechanics.
+ */
+function _prune_lab_modules(
+    deploy_results: Record<string, DeployResult>,
+    lab_ids: Set<string>,
+): [number, Record<string, DeployResult>] {
+    return _prune_modules_by(deploy_results, (p) => surface_tiers.is_lab_artefact(p, lab_ids));
+}
+
+// --- Scoped-projection prune (road-to-credible-install Phase 2) ----------
+//
+// `projection.mode: scoped` narrows a GLOBAL deploy to the active profile's
+// packs (workspaces `engineering` + `agent-config-maintainer` by default,
+// unioned with a `runtime.active_packs` overlay, expanded over the packs.yml
+// `requires` graph). Mirrors the core-only lab prune above — same
+// `_prune_modules_by` mechanics, a different predicate.
+
+/** `workspaces` values whose packs are ALWAYS active under `scoped` mode. */
+const SCOPED_ACTIVE_WORKSPACES: ReadonlySet<string> = new Set(['engineering', 'agent-config-maintainer']);
+
+interface PackRecord {
+    id: string;
+    workspaces: string[];
+    requires: string[];
+}
+
+/**
+ * Parse `src/config/discovery/packs.yml` into `{id, workspaces, requires}`
+ * records. `requires` falls back to the legacy `requires_hint` field name
+ * when `requires` is absent.
+ *
+ * Deliberately THROWS on a missing file or a parse result that is not a
+ * list — an empty active-pack set would be the LEAST safe fallback here
+ * (it would prune every tagged artefact, the opposite of the fail-safe
+ * contract). The caller wraps this in a try/catch that restores the full
+ * tree on any error instead.
+ */
+function _load_packs_registry(package_root: string): PackRecord[] {
+    const vocab_path = path.join(package_root, 'src', 'config', 'discovery', 'packs.yml');
+    const data = yamlSafeLoad(readText(vocab_path));
+    if (!Array.isArray(data)) {
+        throw new Error(`packs.yml did not parse to a list: ${vocab_path}`);
+    }
+    const out: PackRecord[] = [];
+    for (const entry of data) {
+        if (!_isPlainObject(entry)) continue;
+        const id = entry['id'];
+        if (typeof id !== 'string' || id === '') continue;
+        const workspaces_raw = entry['workspaces'];
+        const workspaces = Array.isArray(workspaces_raw)
+            ? workspaces_raw.filter((w): w is string => typeof w === 'string')
+            : [];
+        const requires_raw = entry['requires'] ?? entry['requires_hint'];
+        const requires = Array.isArray(requires_raw)
+            ? requires_raw.filter((r): r is string => typeof r === 'string')
+            : [];
+        out.push({ id, workspaces, requires });
+    }
+    return out;
+}
+
+/**
+ * Active pack id set for `scoped` mode: every pack whose `workspaces`
+ * intersects `SCOPED_ACTIVE_WORKSPACES`, unioned with `runtime_active_packs`,
+ * expanded over the `requires` graph (transitive closure).
+ */
+function _compute_active_pack_ids(
+    packs: readonly PackRecord[],
+    runtime_active_packs: readonly string[],
+): Set<string> {
+    const by_id = new Map<string, PackRecord>();
+    for (const p of packs) by_id.set(p.id, p);
+
+    const active = new Set<string>();
+    for (const p of packs) {
+        if (p.workspaces.some((w) => SCOPED_ACTIVE_WORKSPACES.has(w))) {
+            active.add(p.id);
+        }
+    }
+    for (const id of runtime_active_packs) {
+        active.add(id);
+    }
+
+    let frontier = [...active];
+    while (frontier.length > 0) {
+        const next: string[] = [];
+        for (const id of frontier) {
+            const rec = by_id.get(id);
+            if (rec === undefined) continue;
+            for (const dep of rec.requires) {
+                if (!active.has(dep)) {
+                    active.add(dep);
+                    next.push(dep);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return active;
+}
+
+/**
+ * Read the GLOBAL settings document that governs a global deploy, if one
+ * already exists on disk — the wizard's canonical typed-subdir location
+ * (`<event4u_root>/settings/.agent-settings.yml`, matching
+ * `src/server/routes/settings.ts`'s `SETTINGS_RELATIVE`) first, the legacy
+ * flat root (`<event4u_root>/.agent-settings.yml`) second. Returns `null`
+ * when neither exists — a genuinely fresh machine with no prior settings
+ * artefact of any kind.
+ */
+function _resolve_global_settings_doc(): Record<string, unknown> | null {
+    const root = user_global_paths.event4u_root();
+    const canonical = path.join(root, 'settings', SETTINGS_FILE);
+    if (pathExists(canonical)) return _load_yaml_doc(canonical);
+    const legacy = path.join(root, SETTINGS_FILE);
+    if (pathExists(legacy)) return _load_yaml_doc(legacy);
+    return null;
+}
+
+/**
+ * Resolve the effective `projection.mode` + `runtime.active_packs` overlay
+ * for THIS global install.
+ *
+ * An EXISTING global settings file (any prior install, wizard-written or
+ * hand-edited) is authoritative: a missing `projection.mode` key, an
+ * unreadable file, or an explicit non-`scoped` value ALL resolve to
+ * `legacy-all` — the upgrade-compat contract (an install that never opted in
+ * stays unscoped). Only when NO global settings file exists yet — before the
+ * wizard's `/api/v1/wizard/finish` route has ever written one on this
+ * machine — does resolution fall through to the packaged template's own
+ * default, the value a fresh install is about to receive.
+ */
+function _resolve_scoped_projection(
+    package_root: string,
+): { mode: 'scoped' | 'legacy-all'; active_packs: string[] } {
+    const doc = _resolve_global_settings_doc() ?? _load_default_settings(package_root);
+    const projection = _isPlainObject(doc['projection']) ? (doc['projection'] as Record<string, unknown>) : {};
+    const mode: 'scoped' | 'legacy-all' = projection['mode'] === 'scoped' ? 'scoped' : 'legacy-all';
+    const runtime = _isPlainObject(doc['runtime']) ? (doc['runtime'] as Record<string, unknown>) : {};
+    const active_packs_raw = runtime['active_packs'];
+    const active_packs = Array.isArray(active_packs_raw)
+        ? active_packs_raw.filter((v): v is string => typeof v === 'string')
+        : [];
+    return { mode, active_packs };
+}
+
+/**
+ * Prune every skill/command artefact whose `packs:` frontmatter is
+ * non-empty AND has no intersection with `active_ids`. Untagged artefacts
+ * (empty `packs:` frontmatter) are core/shared and always kept.
+ */
+function _prune_scoped_modules(
+    deploy_results: Record<string, DeployResult>,
+    active_ids: ReadonlySet<string>,
+): [number, Record<string, DeployResult>] {
+    return _prune_modules_by(deploy_results, (p) => {
+        const packs = surface_tiers.frontmatter_packs(p);
+        if (packs.size === 0) return false;
+        for (const id of packs) {
+            if (active_ids.has(id)) return false;
+        }
+        return true;
+    });
+}
+
 function install_global(
     tools: Set<string>,
     force: boolean,
@@ -3283,6 +3465,27 @@ function install_global(
         info(`  tools=${merged_tools.join(',')}`);
     }
 
+    // Installer drift report (measurement only, never a gate — see
+    // `_lib/install_drift.ts`). Printed here because this is the only
+    // moment the information is actionable: right before the redeploy below
+    // overwrites whatever the consumer may have locally edited since the
+    // last install. Same project-scoping the manifest update further below
+    // uses (skipped inside the agent-config source repo itself, where the
+    // manifest would be untracked noise).
+    if (
+        project_root !== null &&
+        pathExists(_resolve_settings_read(project_root)) &&
+        !isDir(path.join(project_root, '.agent-src.uncondensed'))
+    ) {
+        const drift = collect_drift(project_root);
+        if (!state.QUIET) {
+            process.stdout.write('\n');
+            for (const line of format_drift_report(drift).replace(/\n$/, '').split('\n')) {
+                info(line);
+            }
+        }
+    }
+
     const package_root = _resolve_package_root_for_global();
     let deploy_results = _deploy_global_content(tools, force, package_root, written);
 
@@ -3303,6 +3506,35 @@ function install_global(
         }
     }
 
+    // Scoped-projection prune (road-to-credible-install Phase 2 default
+    // flip): when the GLOBAL settings governing this install resolve to
+    // `projection.mode: scoped` (fresh installs; an EXISTING install without
+    // the key, or with any other value, stays untouched — see
+    // `_resolve_scoped_projection`), drop every skill/command artefact whose
+    // `packs:` frontmatter carries no intersection with the active pack set.
+    // A failed resolution (corrupt packs.yml, any thrown error) is caught
+    // here and restores the full tree — never a partial or crashed prune.
+    try {
+        const { mode, active_packs } = _resolve_scoped_projection(package_root);
+        if (mode === 'scoped') {
+            const packs_registry = _load_packs_registry(package_root);
+            const active_ids = _compute_active_pack_ids(packs_registry, active_packs);
+            let scoped_pruned: number;
+            [scoped_pruned, deploy_results] = _prune_scoped_modules(deploy_results, active_ids);
+            if (!state.QUIET) {
+                info(
+                    `🧹 Scoped install: pruned ${scoped_pruned} non-active-pack artefact(s) ` +
+                        `(active packs: ${[...active_ids].sort().join(', ') || '(none)'}). ` +
+                        'Set projection.mode: legacy-all in .agent-settings.yml to restore the full surface.',
+                );
+            }
+        }
+    } catch (e) {
+        if (!state.QUIET) {
+            warn(`Scoped-projection prune failed — restoring full tree (${String(e)}).`);
+        }
+    }
+
     const failed_tools = new Set<string>(
         Object.keys(deploy_results).filter(
             (tool_id) => (deploy_results[tool_id] as DeployResult)[2] === 'deploy_failed',
@@ -4794,5 +5026,14 @@ export {
     ensure_cline_bridge,
     ensure_windsurf_bridge,
     ensure_gemini_bridge,
+    // road-to-credible-install Phase 2: exported for the scoped-projection
+    // prune unit tests.
+    _prune_modules_by,
+    _prune_lab_modules,
+    _prune_scoped_modules,
+    _load_packs_registry,
+    _compute_active_pack_ids,
+    _resolve_global_settings_doc,
+    _resolve_scoped_projection,
 };
-export type { Options };
+export type { Options, PackRecord, DeployResult };

package/src/scripts/iron_law_sha.ts

@@ -26,6 +26,7 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { artefact_roots } from './_lib/agent_src.js';
+import { KERNEL_RULE_IDS } from './_lib/kernel_rules.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 
@@ -60,18 +61,8 @@ function _isFile(p: string): boolean {
     }
 }
 
-// Locked kernel set — kept in sync with measure_rule_budget.KERNEL_RULES.
-const KERNEL_RULES: readonly string[] = [
-    'agent-authority',
-    'ask-when-uncertain',
-    'commit-policy',
-    'direct-answers',
-    'language-and-tone',
-    'no-cheap-questions',
-    'non-destructive-by-default',
-    'scope-control',
-    'verify-before-complete',
-];
+// Locked kernel set — single-sourced in _lib/kernel_rules.ts.
+const KERNEL_RULES: readonly string[] = KERNEL_RULE_IDS;
 
 // Python: re.compile(r"```(?:[^\n]*\n)([\s\S]*?)```")
 const _FENCE_RE = /```(?:[^\n]*\n)([\s\S]*?)```/g;