@rackbops/ac-agent 2.0.0-alpha.8 → 2.0.0-alpha.9

package/dist/ac-agent.mjs

@@ -43,7 +43,7 @@ function _mergeNamespaces(n, m) {
 }
 
 var name = "@rackbops/ac-agent";
-var version = "2.0.0-alpha.8";
+var version = "2.0.0-alpha.9";
 var type = "module";
 var description = "The per-machine host agent (installed with npx @rackbops/ac-agent): an HTTPS health server plus install/status/uninstall for a Windows logon task or a systemd user unit.";
 var bin = {
@@ -51,7 +51,8 @@ var bin = {
 };
 var files = [
 	"dist/ac-agent.mjs",
-	"README.md"
+	"README.md",
+	"data/"
 ];
 var engines = {
 	node: ">=24"
@@ -1260,11 +1261,20 @@ function reposRootEnvOverride(env) {
     requireAbsolute(raw, "AC_AGENT_REPOS_ROOT");
     return raw;
 }
+function claudeProjectsDirEnvOverride(env) {
+    const raw = env?.AC_AGENT_CLAUDE_PROJECTS_DIR;
+    if (raw === undefined || raw.trim() === "")
+        return null;
+    requireAbsolute(raw, "AC_AGENT_CLAUDE_PROJECTS_DIR");
+    return raw;
+}
 function loadConfig(dir, deps) {
     const configPath = path.join(dir, "agent.toml");
     const envPort = portEnvOverride(deps.env);
     const envReposRoot = reposRootEnvOverride(deps.env);
+    const envClaudeProjectsDir = claudeProjectsDirEnvOverride(deps.env);
     const defaultReposRoot = () => path.join(deps.homedir(), "repos");
+    const defaultClaudeProjectsDir = () => path.join(deps.homedir(), ".claude", "projects");
     const text = deps.readFile(configPath);
     if (text === null) {
         return {
@@ -1273,6 +1283,7 @@ function loadConfig(dir, deps) {
                 bind: DEFAULT_BIND,
                 machine: deps.hostname(),
                 reposRoot: envReposRoot ?? defaultReposRoot(),
+                claudeProjectsDir: envClaudeProjectsDir ?? defaultClaudeProjectsDir(),
             },
             path: configPath,
             source: "defaults",
@@ -1285,6 +1296,10 @@ function loadConfig(dir, deps) {
             bind: typeof raw.bind === "string" ? raw.bind : DEFAULT_BIND,
             machine: typeof raw.machine === "string" ? raw.machine : deps.hostname(),
             reposRoot: envReposRoot ?? (typeof raw.repos_root === "string" ? raw.repos_root : defaultReposRoot()),
+            claudeProjectsDir: envClaudeProjectsDir ??
+                (typeof raw.claude_projects_dir === "string"
+                    ? raw.claude_projects_dir
+                    : defaultClaudeProjectsDir()),
         },
         path: configPath,
         source: "file",
@@ -1297,6 +1312,7 @@ function writeConfig(dir, config, deps) {
         bind: config.bind,
         machine: config.machine,
         repos_root: config.reposRoot,
+        claude_projects_dir: config.claudeProjectsDir,
     }));
     return configPath;
 }
@@ -4885,6 +4901,20 @@ function createApp(deps) {
         deps.logEvent(`grants updated: revision ${validated.set.revision}, ${pluginCount} plugin(s)`);
         return c.json({ ok: true, revision: validated.set.revision, plugins: pluginCount });
     });
+    // Bearer-gated (by the middleware above) but not a verb, exactly like PUT /v1/grants: no
+    // capability, no plugin header -- the Agents panel's Environment section is host-level, like
+    // Ping, so a grant to some plugin would be a fiction (#55, E4 §5 decision 19).
+    app.get("/v1/preflight", async (c) => {
+        if (c.req.header("X-AC-Plugin") !== undefined) {
+            return c.json({ ok: false, error: "preflight is the console's, not a plugin's" }, 403);
+        }
+        const report = await deps.preflight();
+        const okCount = report.rows.filter((r) => r.status === "ok").length;
+        const notOkCount = report.rows.length - okCount;
+        const perRow = report.rows.map((r) => `${r.cmd}=${r.status}`).join(", ");
+        deps.logEvent(`preflight: ${okCount} ok, ${notOkCount} not ok (${perRow}) searchPath=${report.searchPath}`);
+        return c.json({ ok: true, ...report });
+    });
     mountVerbs(app, deps.verbs, { grants: deps.grants, machine: deps.machine });
     app.notFound((c) => c.json({ error: "no such verb" }, 404));
     return app;
@@ -33745,6 +33775,132 @@ var cert = /*#__PURE__*/Object.freeze({
   nonInternalIPv4: nonInternalIPv4
 });
 
+const NONCE_PREFIX = ".ac-agent-vfs-probe-";
+/** Strips a single trailing separator (`path.win32.normalize` never removes the one on a root like
+ *  `C:\`, so this only ever trims an operator-typed trailing slash on a real subdirectory). */
+function normalizeRoot$1(p) {
+    const normalized = path.win32.normalize(p);
+    return normalized.length > 3 && normalized.endsWith("\\") ? normalized.slice(0, -1) : normalized;
+}
+/** Case-insensitive prefix compare on normalized absolute paths (Windows paths are case-preserving,
+ *  not case-sensitive by default -- `fsutil ... queryCaseSensitiveInfo` on #263's own SHIORI
+ *  investigation confirmed this off everywhere checked). Returns the path relative to `root` when
+ *  `dir` lies under it (possibly `""` when they're equal), or `null` when `dir` is elsewhere
+ *  entirely (an `AC_AGENT_STATE_DIR` on another drive, say) -- never guessed via `path.relative`,
+ *  which always returns *some* string (with `..` segments) regardless of actual nesting. */
+function relativeUnder(root, dir) {
+    const normRoot = normalizeRoot$1(root);
+    const normDir = path.win32.normalize(dir);
+    const rootLower = normRoot.toLowerCase();
+    const dirLower = normDir.toLowerCase();
+    if (dirLower === rootLower)
+        return "";
+    if (dirLower.startsWith(`${rootLower}\\`))
+        return normDir.slice(normRoot.length + 1);
+    return null;
+}
+/** A dir can lie under either root -- the default layout puts `stateDir` under `%LOCALAPPDATA%` and
+ *  `configDir` under `%APPDATA%` (`paths.ts`), but an override could put either dir under either
+ *  root, so both roots are tried for both dirs rather than assuming the default pairing. */
+function findRootMatch(dir, localAppData, appData) {
+    const localRel = relativeUnder(localAppData, dir);
+    if (localRel !== null)
+        return { rel: localRel, branch: "Local" };
+    if (appData !== undefined && appData !== "") {
+        const roamingRel = relativeUnder(appData, dir);
+        if (roamingRel !== null)
+            return { rel: roamingRel, branch: "Roaming" };
+    }
+    return null;
+}
+function detectAppDataVirtualization(deps) {
+    if (deps.platform !== "win32")
+        return { virtualized: false };
+    const localAppData = deps.env.LOCALAPPDATA;
+    if (localAppData === undefined || localAppData === "")
+        return { virtualized: false };
+    const appData = deps.env.APPDATA;
+    const candidates = [];
+    const stateMatch = findRootMatch(deps.stateDir, localAppData, appData);
+    if (stateMatch !== null)
+        candidates.push({ dir: deps.stateDir, ...stateMatch });
+    const configMatch = findRootMatch(deps.configDir, localAppData, appData);
+    if (configMatch !== null)
+        candidates.push({ dir: deps.configDir, ...configMatch });
+    const packagesDir = path.win32.join(localAppData, "Packages");
+    for (const candidate of candidates) {
+        const nonceFileName = `${NONCE_PREFIX}${deps.nonce()}`;
+        const nonceFilePath = path.win32.join(candidate.dir, nonceFileName);
+        try {
+            deps.fs.writeFile(nonceFilePath, "probe");
+        }
+        catch {
+            // Can't even write the probe file (permissions, a read-only fs, disk full, ...) -- this
+            // candidate is unverifiable, not a hard failure. Without this, a write error would propagate
+            // straight out of `status` (which, before this guard existed, never wrote anything at all) as
+            // a raw, confusing exception instead of a graceful `virtualized: false`.
+            continue;
+        }
+        try {
+            let packageNames;
+            try {
+                packageNames = deps.fs.readdir(packagesDir);
+            }
+            catch {
+                // No `Packages` dir at all -- not virtualized for this candidate (and, since it's the same
+                // physical dir for every candidate, not virtualized for any of them either).
+                continue;
+            }
+            for (const pkg of packageNames) {
+                try {
+                    const vfsPath = path.win32.join(localAppData, "Packages", pkg, "LocalCache", candidate.branch, candidate.rel);
+                    const probePath = path.win32.join(vfsPath, nonceFileName);
+                    if (deps.fs.exists(probePath)) {
+                        return { virtualized: true, packageFamily: pkg, vfsPath };
+                    }
+                }
+                catch {
+                    // An unreadable package dir is skipped, not a hard failure.
+                }
+            }
+        }
+        finally {
+            deps.fs.removeFile(nonceFilePath);
+        }
+    }
+    return { virtualized: false };
+}
+/** The exact refusal text `installService` throws (`service/index.ts`) -- pinned by
+ *  `service.test.ts`. */
+function installRefusalMessage(packageFamily, vfsPath) {
+    return `install ran inside a packaged app (${packageFamily}), which virtualizes AppData: the files landed under ${vfsPath} where the logon task cannot see them. Run ac-agent install from a normal PowerShell window, not from a session started by the Claude desktop app.`;
+}
+/** The one-line warning `status` prints to stderr and `serve` logs once at startup when the dirs it
+ *  resolved are virtualized -- neither refuses (a status/serve run from a virtualized session is
+ *  informative, or in `serve`'s case actively working within that same session; only a fresh
+ *  `install` registering a task nothing can see is refused). */
+function virtualizationWarningLine(packageFamily, stateDir) {
+    return `warning: this session's AppData is virtualized (${packageFamily}); the logon task cannot see ${stateDir} -- see README, Install`;
+}
+
+/** Shared by `installService` and `status` so both check the same two dirs the same way -- exported
+ *  for `cli.ts`'s `status` wiring, which needs the full result (not just the boolean `status` puts on
+ *  `StatusResult`) to name the offending package in its stderr warning. */
+function detectVirtualization(deps) {
+    return detectAppDataVirtualization({
+        platform: deps.osPlatform,
+        env: deps.env ?? {},
+        stateDir: deps.stateDir,
+        configDir: deps.configDir,
+        fs: {
+            writeFile: deps.writeFile,
+            readdir: deps.readdir,
+            exists: deps.exists,
+            removeFile: deps.removeFile,
+        },
+        nonce: deps.nonce,
+    });
+}
 function bundleTargetPath(stateDir) {
     return path.join(stateDir, "bin", "ac-agent.mjs");
 }
@@ -33771,6 +33927,14 @@ async function installService(deps) {
         writeFile: (p, content, mode) => deps.writeFile(p, content, mode),
     });
     const fp = fingerprint(certPem);
+    // #263: refuse before registering a task/unit nothing can ever see, rather than leave a broken
+    // registration behind for `status`/`start` to fail against later. Must run after the state-dir
+    // writes above (so a genuinely virtualized session's own writes are what the probe finds) and
+    // before `deps.platform.install` (which is what actually registers the task/unit on Windows).
+    const virtualization = detectVirtualization(deps);
+    if (virtualization.virtualized) {
+        throw new Error(installRefusalMessage(virtualization.packageFamily, virtualization.vfsPath));
+    }
     const result = await deps.platform.install({
         nodePath: deps.nodePath,
         bundlePath,
@@ -33802,6 +33966,7 @@ async function status(deps, now = () => new Date()) {
             plugins: Object.keys(readGrantsResult.set.grants).length,
         }
         : null;
+    const virtualization = detectVirtualization(deps);
     return {
         configPath: loaded.path,
         configSource: loaded.source,
@@ -33813,6 +33978,7 @@ async function status(deps, now = () => new Date()) {
         health,
         reposRoot: loaded.config.reposRoot,
         grants,
+        virtualized: virtualization.virtualized,
     };
 }
 /** Generates a one-time pairing code (#48): refuses when already paired unless `force` (which is how
@@ -33876,6 +34042,7 @@ async function uninstall(deps, options) {
     deps.removeFile(path.join(deps.stateDir, "token.sha256"));
     deps.removeFile(path.join(deps.stateDir, "pair.json"));
     deps.removeFile(path.join(deps.stateDir, "grants.json"));
+    deps.removeDir(path.join(deps.stateDir, "scans"));
     if (options.purge) {
         deps.removeFile(path.join(deps.configDir, "agent.toml"));
     }
@@ -34485,6 +34652,7 @@ function systemdUnitPath(homedir) {
 async function buildServiceDeps(overrides = {}) {
     const os = await import('node:os');
     const fs = await import('node:fs');
+    const crypto = await import('node:crypto');
     const { resolveDirs } = await Promise.resolve().then(function () { return paths; });
     const { nonInternalIPv4 } = await Promise.resolve().then(function () { return cert; });
     const { fileURLToPath } = await import('node:url');
@@ -34520,6 +34688,9 @@ async function buildServiceDeps(overrides = {}) {
                 // already gone
             }
         },
+        removeDir: (p) => {
+            fs.rmSync(p, { recursive: true, force: true });
+        },
         killProcess: (pid) => {
             try {
                 process.kill(pid);
@@ -34534,13 +34705,17 @@ async function buildServiceDeps(overrides = {}) {
         portOverride: overrides.port,
         reposRootOverride: overrides.reposRoot,
         env: process.env,
+        osPlatform: process.platform,
+        readdir: (p) => fs.readdirSync(p),
+        exists: (p) => fs.existsSync(p),
+        nonce: () => crypto.randomBytes(6).toString("hex"),
         ips: nonInternalIPv4(os.networkInterfaces()),
         nodePath: process.execPath,
         user: os.userInfo().username,
         platform,
         print: (line) => process.stdout.write(`${line}\n`),
         fetchHealth: async (healthPort, certPem, expectedFingerprint) => {
-            const { Agent, fetch: undiciFetch } = await Promise.resolve().then(function () { return index; });
+            const { Agent, fetch: undiciFetch } = await Promise.resolve().then(function () { return index$2; });
             const agent = new Agent({
                 connect: {
                     ca: certPem,
@@ -34565,6 +34740,7 @@ async function buildServiceDeps(overrides = {}) {
 async function realServe(overrides = {}) {
     const os = await import('node:os');
     const fs = await import('node:fs');
+    const crypto = await import('node:crypto');
     const { resolveDirs } = await Promise.resolve().then(function () { return paths; });
     const { ensureCert, nonInternalIPv4 } = await Promise.resolve().then(function () { return cert; });
     const { acquire, release } = await Promise.resolve().then(function () { return lock; });
@@ -34578,8 +34754,10 @@ async function realServe(overrides = {}) {
     const { findExecutable } = await Promise.resolve().then(function () { return which; });
     const { createJobRegistry } = await Promise.resolve().then(function () { return registry$1; });
     const { createScanRegistry } = await Promise.resolve().then(function () { return registry; });
+    const { registerScanKinds } = await Promise.resolve().then(function () { return index$1; });
     const { registerScanVerbs } = await Promise.resolve().then(function () { return scan; });
     const { readGrants, writeGrants, createGrantState } = await Promise.resolve().then(function () { return grants; });
+    const { runPreflight } = await Promise.resolve().then(function () { return index; });
     // `--config-dir`/`--state-dir` (E4 finding 13, #241) are what `install` bakes into the registered
     // task/unit, so a `serve` launched that way never falls back to re-resolving from its own
     // environment (a Task Scheduler process / systemd --user unit does not see the installing
@@ -34635,6 +34813,32 @@ async function realServe(overrides = {}) {
         rename: (from, to) => fs.renameSync(from, to),
         appendFile: (p, data) => fs.appendFileSync(p, data),
     });
+    // #263: a `serve` launched from a session whose AppData is virtualized by a packaged app still
+    // works (everything it reads/writes goes through the same virtualized view within that session),
+    // so this only warns, once, rather than refusing the way `install` does.
+    const virtualizationCheck = detectAppDataVirtualization({
+        platform: process.platform,
+        env: process.env,
+        stateDir: dirs.stateDir,
+        configDir: dirs.configDir,
+        fs: {
+            writeFile: (p, content) => fs.writeFileSync(p, content),
+            readdir: (p) => fs.readdirSync(p),
+            exists: (p) => fs.existsSync(p),
+            removeFile: (p) => {
+                try {
+                    fs.unlinkSync(p);
+                }
+                catch {
+                    // already gone
+                }
+            },
+        },
+        nonce: () => crypto.randomBytes(6).toString("hex"),
+    });
+    if (virtualizationCheck.virtualized) {
+        log$1.write(virtualizationWarningLine(virtualizationCheck.packageFamily, dirs.stateDir));
+    }
     const registry$3 = createVerbRegistry();
     const run = createRun();
     const repoFs = {
@@ -34649,12 +34853,7 @@ async function realServe(overrides = {}) {
         logEvent: (message) => log$1.write(message),
     });
     registerOpenVerb(registry$3, { spawn: createSpawn(), platform: process.platform });
-    // Empty at this PR (#49, 49c): the #52 scans (context-pressure, subagent-cost,
-    // memory-footprint, toolchain-inventory) are what register a kind into this -- this file only
-    // freezes and mounts whatever's registered, live-only wiring like every verb group above.
-    const scans = createScanRegistry();
-    registerScanVerbs(registry$3, scans, { logEvent: (message) => log$1.write(message) });
-    const which$1 = (name) => findExecutable(name, process.env, process.platform, {
+    const whichFs = {
         exists: (p) => fs.existsSync(p),
         isExecutable: (p) => {
             try {
@@ -34665,7 +34864,67 @@ async function realServe(overrides = {}) {
                 return false;
             }
         },
+    };
+    // The optional second (env) parameter is #55's own addition: claude.ts/gh.ts's own deps type
+    // `which` as one-argument (a required second parameter would not be assignable to that, tsc
+    // 5.9 TS2322), while runPreflight's deps call it with the refreshed PATH on every probe.
+    const which$1 = (name, env = process.env) => findExecutable(name, env, process.platform, whichFs);
+    // context-pressure and subagent-cost (#52, 52a) register here; memory-footprint and
+    // toolchain-inventory (52b) grow this same call. registerScanKinds must run before
+    // registerScanVerbs, which freezes the registry before mounting one verb per kind.
+    const scans = createScanRegistry();
+    registerScanKinds(scans, {
+        projectsRoot: () => loaded.config.claudeProjectsDir,
+        stateDir: dirs.stateDir,
+        fs: {
+            readFile: (p) => {
+                try {
+                    return fs.readFileSync(p);
+                }
+                catch {
+                    return null;
+                }
+            },
+            readdir: (p) => {
+                try {
+                    return fs.readdirSync(p).map((name) => ({ name }));
+                }
+                catch {
+                    return [];
+                }
+            },
+            isDir: (p) => {
+                try {
+                    return fs.statSync(p).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            },
+            stat: (p) => {
+                try {
+                    const s = fs.statSync(p, { bigint: true });
+                    return { mtimeNs: s.mtimeNs, size: Number(s.size) };
+                }
+                catch {
+                    return null;
+                }
+            },
+            writeFile: (p, text) => fs.writeFileSync(p, text),
+            mkdir: (p) => fs.mkdirSync(p, { recursive: true }),
+            rename: (from, to) => fs.renameSync(from, to),
+        },
+        now: Date.now,
+        reposRoot: () => loaded.config.reposRoot,
+        repoFs,
+        which: which$1,
+        homedir: os.homedir,
+        hostname: os.hostname,
+        platform: process.platform,
+        env: process.env,
+        run,
     });
+    registerScanVerbs(registry$3, scans, { logEvent: (message) => log$1.write(message) });
     registerClaudeVerbs(registry$3, {
         jobs: createJobRegistry(),
         resolveRepo: (name) => resolveRepo(loaded.config.reposRoot, name, repoFs),
@@ -34695,6 +34954,18 @@ async function realServe(overrides = {}) {
         logEvent: (message) => log$1.write(message),
         verbs: registry$3,
         grants: grants$1,
+        preflight: () => runPreflight({
+            platform: process.platform,
+            env: process.env,
+            homedir: os.homedir,
+            which: which$1,
+            exists: whichFs.exists,
+            isExecutable: whichFs.isExecutable,
+            readdir: (p) => fs.readdirSync(p),
+            run,
+            now: () => new Date(),
+            machine: loaded.config.machine,
+        }),
     });
     const running = await startServer({
         app,
@@ -34737,6 +35008,14 @@ async function main(argv) {
         status: async () => {
             const { deps } = await buildServiceDeps();
             const result = await status(deps);
+            if (result.virtualized) {
+                // `result.virtualized` only carries the boolean (`StatusResult`'s own shape) -- rerun the
+                // detection once more here to get the package name this line names (#263).
+                const detection = detectVirtualization(deps);
+                if (detection.virtualized) {
+                    process.stderr.write(`${virtualizationWarningLine(detection.packageFamily, deps.stateDir)}\n`);
+                }
+            }
             process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         },
         serve: realServe,
@@ -72726,7 +73005,7 @@ function requireUndici () {
 
 var undiciExports = requireUndici();
 
-var index = /*#__PURE__*/_mergeNamespaces({
+var index$2 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null
 }, [undiciExports]);
 
@@ -72789,6 +73068,7 @@ function createRun(spawnFn = spawn) {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
+        let aborted = false;
         let settled = false;
         const child = spawnFn(cmd, args, {
             cwd: opts.cwd,
@@ -72799,6 +73079,19 @@ function createRun(spawnFn = spawn) {
             // itself is ENOENT and every credential helper is gone -- merge over process.env.
             env: { ...process.env, ...opts.env },
         });
+        const onAbort = () => {
+            aborted = true;
+            child.kill();
+        };
+        // Checked once, right after launch, rather than skipping spawnFn altogether: a caller that
+        // hands in an already-aborted signal still gets a real launch attempt, immediately killed --
+        // never the launch-failure path (comment on RunOptions.signal above).
+        if (opts.signal?.aborted) {
+            onAbort();
+        }
+        else {
+            opts.signal?.addEventListener("abort", onAbort, { once: true });
+        }
         const timer = setTimeout(() => {
             timedOut = true;
             child.kill();
@@ -72809,21 +73102,31 @@ function createRun(spawnFn = spawn) {
         child.stderr?.on("data", (chunk) => {
             stderr += chunk.toString();
         });
+        const cleanup = () => {
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", onAbort);
+        };
         // A launch failure (ENOENT, EACCES, ...) fires here rather than throwing synchronously --
         // resolved as one error row (1.x repo_pull.py:84-89) rather than aborting the whole call.
         child.on("error", (err) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            cleanup();
             resolve({ code: 127, stdout, stderr: err.message, timedOut: false });
         });
         child.on("close", (code) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, stdout, stderr, timedOut });
+            cleanup();
+            resolve({
+                code: code ?? 1,
+                stdout,
+                stderr,
+                timedOut,
+                ...(aborted ? { aborted: true } : {}),
+            });
         });
     });
 }
@@ -73909,12 +74212,24 @@ var gh = /*#__PURE__*/Object.freeze({
   registerGhVerb: registerGhVerb
 });
 
+/** Strips one pair of surrounding double quotes from a PATH entry ("C:\Program Files\Git\cmd" is
+ *  legal in a Windows PATH, and `CreateProcess` strips it before use) -- an entry left quoted
+ *  would otherwise never match a real file and read as `missing`. Harmless on POSIX, where a real
+ *  directory name wrapped in literal quotes is not a thing that happens. */
+function unquote(entry) {
+    return entry.length >= 2 && entry.startsWith('"') && entry.endsWith('"')
+        ? entry.slice(1, -1)
+        : entry;
+}
 function findExecutable(name, env, platform, fs) {
     const pathVar = env.PATH ?? env.Path ?? "";
     const sep = platform === "win32" ? ";" : ":";
     // A PATH entry that doesn't exist on disk is skipped by the exists() checks below, never thrown
     // -- there's nothing here to throw on a plain string split, and exists() is a pure boolean.
-    const dirs = pathVar.split(sep).filter((d) => d !== "");
+    const dirs = pathVar
+        .split(sep)
+        .filter((d) => d !== "")
+        .map(unquote);
     // path.win32/path.posix explicitly, never the bare path.join/path.dirname -- those pick their
     // behavior from the OS this code is actually running on, not from the `platform` parameter, so
     // testing "linux" logic from a Windows dev box (or vice versa) would silently join with the
@@ -73925,9 +74240,12 @@ function findExecutable(name, env, platform, fs) {
             const exePath = join(dir, `${name}.exe`);
             if (fs.exists(exePath))
                 return { found: true, path: exePath };
-            if (fs.exists(join(dir, `${name}.cmd`)) || fs.exists(join(dir, `${name}.bat`))) {
-                return { found: false, reason: "shim" };
-            }
+            const cmdPath = join(dir, `${name}.cmd`);
+            if (fs.exists(cmdPath))
+                return { found: false, reason: "shim", path: cmdPath };
+            const batPath = join(dir, `${name}.bat`);
+            if (fs.exists(batPath))
+                return { found: false, reason: "shim", path: batPath };
         }
         return { found: false, reason: "not-found" };
     }
@@ -74117,6 +74435,1221 @@ var registry = /*#__PURE__*/Object.freeze({
   createScanRegistry: createScanRegistry
 });
 
+/**
+ * Python-compatible JSON, byte for byte (#52, 52a, E4 plan item 2): #52's acceptance is a byte diff
+ * against 1.x's own cache file, and neither `JSON.stringify`'s formatting nor JavaScript's
+ * number model matches `json.dumps`'s. This module is the whole gap: `ensure_ascii` escaping,
+ * `indent=2` layout, key-insertion order, integers as integers, and -- the hard part -- a per-key
+ * set of "this one is a Python float" so its number is formatted by `repr()`, not by
+ * `Number#toString()` (which agrees with `repr` on the digits but not on when to use scientific
+ * notation, and never renders `85` as `85.0`).
+ */
+/** Every UTF-16 code unit outside 0x20-0x7E becomes a lowercase `\uXXXX` (DEL and lone surrogates
+ *  included), except the seven short escapes Python's encoder also special-cases; `/` is not
+ *  escaped. Astral characters are already surrogate pairs in a JS string, so iterating code UNITS
+ *  (not code points) reproduces Python's own UTF-16-based `\uXXXX` pairing for them automatically. */
+function escapeAscii(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        switch (code) {
+            case 0x22:
+                out += '\\"';
+                break;
+            case 0x5c:
+                out += "\\\\";
+                break;
+            case 0x0a:
+                out += "\\n";
+                break;
+            case 0x0d:
+                out += "\\r";
+                break;
+            case 0x09:
+                out += "\\t";
+                break;
+            case 0x08:
+                out += "\\b";
+                break;
+            case 0x0c:
+                out += "\\f";
+                break;
+            default:
+                if (code >= 0x20 && code <= 0x7e) {
+                    out += s[i];
+                }
+                else {
+                    out += `\\u${code.toString(16).padStart(4, "0")}`;
+                }
+        }
+    }
+    return out;
+}
+/** Python's `repr(float)`: the shortest round-trip digits (the same digits `Number#toString`
+ *  produces -- both are shortest-round-trip) laid out by Python's rule -- positional when
+ *  `-4 < decpt <= 16` (an integral value gets a trailing `.0`), otherwise scientific
+ *  `d[.ddd]e±XX` with a sign and at least two exponent digits. `decpt` is the decimal point's
+ *  position relative to the digit string (one past the first digit, e.g. digits "85" at decpt 2
+ *  is "85", at decpt 1 is "8.5"). `-0.0` is handled by sign since `String(-0)` loses the sign. */
+function pyFloatRepr(x) {
+    const negative = x < 0 || Object.is(x, -0);
+    const abs = Math.abs(x);
+    if (abs === 0)
+        return negative ? "-0.0" : "0.0";
+    const exp = abs.toExponential();
+    const match = /^(\d)(?:\.(\d+))?e([+-]\d+)$/.exec(exp);
+    if (match === null)
+        throw new Error(`pyFloatRepr: unexpected toExponential() output ${exp}`);
+    const digits = match[1] + (match[2] ?? "");
+    const e = Number(match[3]);
+    const decpt = e + 1;
+    let body;
+    if (decpt > -4 && decpt <= 16) {
+        if (decpt <= 0) {
+            body = `0.${"0".repeat(-decpt)}${digits}`;
+        }
+        else if (decpt >= digits.length) {
+            body = `${digits}${"0".repeat(decpt - digits.length)}.0`;
+        }
+        else {
+            body = `${digits.slice(0, decpt)}.${digits.slice(decpt)}`;
+        }
+    }
+    else {
+        const mantissa = digits.length === 1 ? digits : `${digits[0]}.${digits.slice(1)}`;
+        const sign = e < 0 ? "-" : "+";
+        body = `${mantissa}e${sign}${String(Math.abs(e)).padStart(2, "0")}`;
+    }
+    return negative ? `-${body}` : body;
+}
+/** Adds 1 to a string of decimal digits, carrying left (e.g. "099" -> "100", "999" -> "1000"). */
+function incrementDecimalDigits(digits) {
+    const chars = digits.split("");
+    for (let i = chars.length - 1; i >= 0; i--) {
+        if (chars[i] !== "9") {
+            chars[i] = String(Number(chars[i]) + 1);
+            return chars.join("");
+        }
+        chars[i] = "0";
+    }
+    return `1${chars.join("")}`;
+}
+/** Python's `round(x, ndigits)`: correctly rounded on the double's EXACT decimal expansion, ties
+ *  to even -- never `toFixed` (rounds ties away from zero) and never `Math.round(x * 10**n) / 10**n`
+ *  (both accumulates float error and still ties away from zero). `toFixed(100)` (the maximum
+ *  `Number.prototype.toFixed` allows) gives the exact expansion for every magnitude this codebase
+ *  rounds (percentages, dollar amounts, unix timestamps) -- comfortably below the ~2^52 mantissa
+ *  precision boundary where an integer part alone would already exhaust it. */
+function pyRound(x, ndigits) {
+    const negative = x < 0 || Object.is(x, -0);
+    const abs = Math.abs(x);
+    const exact = abs.toFixed(100);
+    const dot = exact.indexOf(".");
+    const intPart = exact.slice(0, dot);
+    const fracPart = exact.slice(dot + 1);
+    if (ndigits >= fracPart.length)
+        return negative ? -abs : abs;
+    const keep = fracPart.slice(0, ndigits);
+    const roundDigit = fracPart[ndigits];
+    const rest = fracPart.slice(ndigits + 1);
+    let roundUp;
+    if (roundDigit === undefined || roundDigit < "5") {
+        roundUp = false;
+    }
+    else if (roundDigit > "5") {
+        roundUp = true;
+    }
+    else if (/[1-9]/.test(rest)) {
+        roundUp = true;
+    }
+    else {
+        // An exact tie: round to even, looking at the last digit that survives.
+        const lastKept = ndigits > 0 ? keep[keep.length - 1] : intPart[intPart.length - 1];
+        roundUp = Number(lastKept) % 2 === 1;
+    }
+    let digits = intPart + keep;
+    if (roundUp)
+        digits = incrementDecimalDigits(digits);
+    const newIntLen = digits.length - keep.length;
+    const newInt = digits.slice(0, newIntLen) || "0";
+    const newFrac = digits.slice(newIntLen);
+    const result = Number(ndigits > 0 ? `${newInt}.${newFrac}` : newInt);
+    return negative ? -result : result;
+}
+/** CPython's `st_mtime`: `(double)tv_sec + (double)tv_nsec * 1e-9` (`fill_time` in `posixmodule.c`)
+ *  -- never `mtimeMs / 1000`, which rounds through milliseconds first and can disagree in the last
+ *  bit. Takes `{ sec, nsec }` split from `fs.statSync(p, { bigint: true }).mtimeNs` by the caller. */
+function pyMtime(stat) {
+    return Number(stat.sec) + Number(stat.nsec) * 1e-9;
+}
+function dumpValue(value, key, opts, depth) {
+    if (value === null)
+        return "null";
+    if (value === true)
+        return "true";
+    if (value === false)
+        return "false";
+    if (typeof value === "string")
+        return `"${escapeAscii(value)}"`;
+    if (typeof value === "number") {
+        if (key !== undefined && opts.floatKeys.has(key))
+            return pyFloatRepr(value);
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        const pad = " ".repeat(opts.indent * (depth + 1));
+        const closePad = " ".repeat(opts.indent * depth);
+        const items = value.map((item) => pad + dumpValue(item, undefined, opts, depth + 1));
+        return `[\n${items.join(",\n")}\n${closePad}]`;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return "{}";
+        const pad = " ".repeat(opts.indent * (depth + 1));
+        const closePad = " ".repeat(opts.indent * depth);
+        const items = entries.map(([k, v]) => `${pad}"${escapeAscii(k)}": ${dumpValue(v, k, opts, depth + 1)}`);
+        return `{\n${items.join(",\n")}\n${closePad}}`;
+    }
+    throw new Error(`pyjson.dumps: unsupported value ${JSON.stringify(value)}`);
+}
+/** `json.dumps(data, indent=2)`, byte for byte: `ensure_ascii` on, `": "` / `,\n` separators, two-
+ *  space indent, `[]`/`{}` for empties, key order = insertion order, a key in `floatKeys` formatted
+ *  by `pyFloatRepr` at any depth, everything else numeric rendered as a plain integer. */
+function dumps(value, opts) {
+    return dumpValue(value, undefined, opts, 0);
+}
+/** `Path.write_text(json.dumps(...))` in Python's default text mode: `os.linesep`-terminated lines
+ *  (CRLF on Windows, LF on Linux) and no trailing newline -- `dumps`'s own `\n`s are the encoder's
+ *  structural newlines only (a `\n`/`\r` inside a string VALUE is already `\\n`/`\\r`-escaped by
+ *  `escapeAscii`, never a raw byte), so translating every `\n` is safe and exhaustive. Pure: the
+ *  caller writes the returned text through its own injected `fs.writeFile`, the same seam every
+ *  other disk write in this package goes through. */
+function writeCache(text) {
+    return process.platform === "win32" ? text.replace(/\n/g, "\r\n") : text;
+}
+/** `load_cache`: `null` on a missing or corrupt file, matching either line terminator (`JSON.parse`
+ *  accepts LF or CRLF indifferently, since only whitespace separates tokens). */
+function parseCache(text) {
+    if (text === null)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** `path.dirname(path.join(root, "_"))` (`repos.ts:97`'s normalisation, reused so the root a scan
+ *  reports agrees with resolveRepo's own idea of a normalised root). */
+function normalizeRoot(root) {
+    return path.dirname(path.join(root, "_"));
+}
+
+/**
+ * Shared session/subagent transcript-scan primitives (#52, 52a, E4 plan item 1; 1.x's
+ * `session_scan.py`): the byte-identical helpers `context-pressure.ts` and `subagent-cost.ts` both
+ * derive from a `.claude/projects` transcript, so the two pipelines can't drift on the cross-OS
+ * project-name rule, the timestamp parse, or the line-splitting semantics 1.x's binary file
+ * iteration gives for free and this port has to name explicitly.
+ */
+/** The usage marker every billable transcript record carries, matched on the raw line BYTES --
+ *  both scans byte-prefilter a line (no decode, no parse) before deciding whether it is even worth
+ *  decoding, exactly as 1.x's `_USAGE_MARK in raw` does against a line read in binary mode; this is
+ *  what keeps a ~940MB cold scan from decoding and parsing lines it will discard anyway. */
+const USAGE_MARK = '"cache_read_input_tokens"';
+const USAGE_MARK_BYTES = Buffer.from(USAGE_MARK, "utf8");
+/** Display name for a session: the repo basename, with a worktree folded into its parent
+ *  (`R:\repos\Foo\.claude\worktrees\x` -> `Foo`). Splits on both separators by hand rather than
+ *  through `node:path`: the `cwd` in a transcript was written by whichever OS ran that session, so
+ *  a Windows path has to resolve even when this runs on Linux. */
+function projectName(cwd, fallback) {
+    if (!cwd)
+        return fallback;
+    const parts = cwd
+        .replace(/\\/g, "/")
+        .split("/")
+        .filter((p) => p !== "");
+    const idx = parts.indexOf(".claude");
+    if (idx > 0) {
+        const before = parts[idx - 1];
+        if (before !== undefined)
+            return before;
+    }
+    return parts.length > 0 ? (parts[parts.length - 1] ?? fallback) : fallback;
+}
+// YYYY-MM-DDTHH:MM:SS[.f...](Z|+HH:MM|-HH:MM) -- the transcript's own grammar, not the whole of
+// Python's fromisoformat (which also accepts a bare offset-less string as local time, +HHMM, a
+// space separator, a comma fraction, or a date-only string; Claude Code writes only the Z form,
+// so those are rejected rather than reproduced as a machine-dependent value).
+const TS_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})$/;
+/** ISO-8601 record timestamp -> epoch seconds; `0` when absent/unparseable, used in preference to
+ *  the file mtime so a *resumed* month-old session doesn't enter a rolling window as new work. A
+ *  fraction longer than six digits is truncated to microseconds, as `fromisoformat` does. The
+ *  result is computed as an integer number of microseconds divided by `1e6` -- both operands exact
+ *  integers well under the float64 mantissa's 2^53 boundary for any realistic date, so the double
+ *  is the correctly rounded value Python's `datetime.timestamp()` produces, not an accumulation of
+ *  intermediate rounding. */
+function parseTs(value) {
+    if (typeof value !== "string" || value === "")
+        return 0;
+    const match = TS_PATTERN.exec(value);
+    if (match === null)
+        return 0;
+    const [, y, mo, d, h, mi, s, frac, offset] = match;
+    const fractionDigits = (frac ?? "").slice(0, 6).padEnd(6, "0");
+    const fractionMicros = Number(fractionDigits);
+    let offsetMinutes = 0;
+    if (offset !== "Z") {
+        const sign = offset.startsWith("-") ? -1 : 1;
+        offsetMinutes = sign * (Number(offset.slice(1, 3)) * 60 + Number(offset.slice(4, 6)));
+    }
+    const epochMs = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s)) -
+        offsetMinutes * 60 * 1000;
+    const totalMicros = epochMs * 1000 + fractionMicros;
+    return totalMicros / 1e6;
+}
+/** Splits a buffer into raw line BYTES exactly as Python's binary file iteration does: on `0x0A`
+ *  alone (a `\r` stays on the line, never stripped, and IS included in the returned slice along
+ *  with the `\n`), and a final line with no trailing `\n` is still a line. Returns bytes, not
+ *  decoded text, on purpose: 1.x's own byte-prefilter (`USAGE_MARK_BYTES`/a compact-boundary
+ *  marker) runs before any decode or parse, so a line that never has to be decoded at all (the
+ *  large majority, in a ~940MB cold scan) never is -- decode only the lines that pass. */
+function readLines(buffer) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] === 0x0a) {
+            lines.push(buffer.subarray(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < buffer.length) {
+        lines.push(buffer.subarray(start, buffer.length));
+    }
+    return lines;
+}
+const decoder = new TextDecoder("utf-8", { fatal: true });
+/** Decodes one line's bytes to a string, or `null` on invalid UTF-8 -- the caller treats `null`
+ *  exactly like a JSON parse failure (a torn line, skipped). `fatal: true` with the default
+ *  `ignoreBOM: false` strips a leading BOM exactly as `json.loads(bytes)` does through
+ *  `utf-8-sig`, so a BOM line is parsed, not skipped. **Documented divergence**: 1.x decodes with
+ *  `surrogatepass`, so a line carrying lone-surrogate bytes parses there and is skipped here --
+ *  Claude Code never writes one. Never called with `{ stream: true }`, so reusing one decoder
+ *  instance across every line in a file carries no state between calls. */
+function decodeLine(raw) {
+    try {
+        return decoder.decode(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Python's `int(v or 0)`: a falsy `v` (`null`/`undefined`/`0`/`""`/`false`/`NaN`) becomes `0`
+ *  first; a number truncates toward zero; `true` becomes `1`; an integer-literal string (sign,
+ *  surrounding whitespace and `_` digit separators allowed) parses, anything else throws --
+ *  1.x's `int()` raises there too and nothing catches it, so the scan dies (the verb's own 502). */
+function pyIntOr0(v) {
+    const truthy = !(v === null ||
+        v === undefined ||
+        v === false ||
+        v === 0 ||
+        v === "" ||
+        (typeof v === "number" && Number.isNaN(v)));
+    const value = truthy ? v : 0;
+    if (typeof value === "number")
+        return Math.trunc(value);
+    if (typeof value === "boolean")
+        return 1;
+    if (typeof value === "string") {
+        const trimmed = value.trim().replace(/_/g, "");
+        if (!/^[+-]?\d+$/.test(trimmed)) {
+            throw new Error(`invalid literal for int() with base 10: ${JSON.stringify(value)}`);
+        }
+        return Number.parseInt(trimmed, 10);
+    }
+    throw new Error(`int() argument must be a string or a number, not ${typeof value}`);
+}
+function pathSortKey(p) {
+    // On win32, split on BOTH separators after lower-casing -- Python's `PureWindowsPath`
+    // normalises a `/` to `\` at construction (`_str_normcase`), so a `/`-spelled root (as the
+    // fixture tests and a `/`-configured root use) still sorts by its true components, not as one
+    // opaque whole-string comparison. Production paths built by `path.join` on win32 already use
+    // `\` exclusively, so this only widens what the key recognises as a separator; it never changes
+    // the key for a path that was already all-`\`.
+    return process.platform === "win32" ? p.toLowerCase().split(/[\\/]/) : p.split("/");
+}
+/** Python sorts `Path` objects by comparing their component lists element-wise (`<` on strings --
+ *  UTF-16 code units, identical to Python's code-point order on the BMP), a shorter list that is a
+ *  prefix of a longer one sorting first; on win32 the whole path is lower-cased first
+ *  (`PurePath._str_normcase`). Never `localeCompare`, and never just the raw path string, which
+ *  would order an "a-b" directory before "a"'s own children on some platforms and after on others. */
+function sortPaths(paths) {
+    return [...paths].sort((pathA, pathB) => {
+        const a = pathSortKey(pathA);
+        const b = pathSortKey(pathB);
+        const len = Math.min(a.length, b.length);
+        for (let i = 0; i < len; i++) {
+            const ai = a[i] ?? "";
+            const bi = b[i] ?? "";
+            if (ai < bi)
+                return -1;
+            if (ai > bi)
+                return 1;
+        }
+        return a.length - b.length;
+    });
+}
+/** `*.jsonl` (or `agent-*.jsonl`), case-insensitive on Windows and case-sensitive elsewhere, as
+ *  Python's `Path.glob` matches names. */
+function matchesGlobSuffix(name, suffix) {
+    return process.platform === "win32"
+        ? name.toLowerCase().endsWith(suffix.toLowerCase())
+        : name.endsWith(suffix);
+}
+function matchesGlobPrefixSuffix(name, prefix, suffix) {
+    const n = process.platform === "win32" ? name.toLowerCase() : name;
+    const p = process.platform === "win32" ? prefix.toLowerCase() : prefix;
+    const s = process.platform === "win32" ? suffix.toLowerCase() : suffix;
+    return n.startsWith(p) && n.endsWith(s) && n.length >= p.length + s.length;
+}
+
+/**
+ * Per-session Claude Code context-window occupancy (#52, 52a; 1.x `context_pressure.py`), kind
+ * `context-pressure`, capability `agent.scan.context-pressure`. Producer only -- the reader
+ * (`overview_summary`, the 7-day window) is E7's and pure over this payload, not ported here.
+ *
+ * Privacy: deserialises exactly six things -- `type`, `subtype`, `timestamp`, `cwd`,
+ * `message.{id,model,usage}`. `message.content` is never touched.
+ */
+const COMPACT_MARK_BYTES = Buffer.from("compact_boundary", "utf8");
+// Measured per-model context windows (context_pressure.py:51-58) -- not inferred from the family
+// name, so a family rule never silently mis-sizes a model whose tier moved. Exported so
+// subagent-cost.test.ts can assert every windowed model is also priced (a model here but missing
+// from subagent-cost's PRICES contributes tokens at zero cost, understating silently).
+const WINDOWS = {
+    "claude-opus-4-8": 1_000_000,
+    "claude-opus-5": 1_000_000,
+    "claude-fable-5": 1_000_000,
+    "claude-sonnet-5": 1_000_000,
+    "claude-sonnet-4-6": 200_000,
+    "claude-haiku-4-5-20251001": 200_000,
+};
+const TIERS = [200_000, 1_000_000];
+function windowFor(model, occupancy) {
+    const win = WINDOWS[model];
+    if (win !== undefined)
+        return { window: win, mapped: true };
+    for (const tier of TIERS) {
+        if (occupancy <= tier)
+            return { window: tier, mapped: false };
+    }
+    return { window: TIERS[TIERS.length - 1], mapped: false };
+}
+function isPlainObject$1(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Peak occupancy (and compaction count) for one session log, or `null` if it holds no usage rows
+ *  at all. Byte-prefilters before any `JSON.parse` -- the scan is I/O-bound, and parsing every line
+ *  instead of the usage-bearing ones is the one thing that would make it slow. */
+function scanFile$1(fileBuffer, mtime, size, stem, parentName) {
+    let peakTokens = 0;
+    let peakPct = 0;
+    let peakModel = "";
+    let peakWindow = 0;
+    let peakMapped = true;
+    let turns = 0;
+    let compactions = 0;
+    let drops = 0;
+    let lastAt = 0;
+    let cwd = "";
+    let prevOcc = 0;
+    const seenIds = new Set();
+    const unmapped = new Set();
+    for (const raw of readLines(fileBuffer)) {
+        const hasUsage = raw.includes(USAGE_MARK_BYTES);
+        if (!hasUsage && !raw.includes(COMPACT_MARK_BYTES))
+            continue;
+        const text = decodeLine(raw);
+        if (text === null)
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (!isPlainObject$1(rec))
+            continue;
+        if (rec.type === "system" && rec.subtype === "compact_boundary") {
+            compactions++;
+            prevOcc = 0;
+            continue;
+        }
+        if (!hasUsage || rec.type !== "assistant")
+            continue;
+        const msg = rec.message;
+        if (!isPlainObject$1(msg))
+            continue;
+        const usage = msg.usage;
+        if (!isPlainObject$1(usage))
+            continue;
+        const model = String(msg.model || "");
+        if (model === "<synthetic>")
+            continue;
+        const mid = msg.id;
+        if (mid) {
+            const midStr = String(mid);
+            if (seenIds.has(midStr))
+                continue;
+            seenIds.add(midStr);
+        }
+        const occ = pyIntOr0(usage.input_tokens) +
+            pyIntOr0(usage.cache_read_input_tokens) +
+            pyIntOr0(usage.cache_creation_input_tokens);
+        if (occ <= 0)
+            continue;
+        turns++;
+        if (!cwd)
+            cwd = String(rec.cwd || "");
+        const ts = parseTs(rec.timestamp);
+        if (ts > lastAt)
+            lastAt = ts;
+        const { window: win, mapped } = windowFor(model, occ);
+        if (!mapped && model)
+            unmapped.add(model);
+        const pct = win ? (occ / win) * 100 : 0;
+        if (pct > peakPct) {
+            peakPct = pct;
+            peakTokens = occ;
+            peakModel = model;
+            peakWindow = win;
+            peakMapped = mapped;
+        }
+        if (prevOcc && prevOcc - occ >= 50_000 && occ <= prevOcc * 0.7) {
+            drops++;
+        }
+        prevOcc = occ;
+    }
+    if (!turns)
+        return null;
+    return {
+        id: stem.slice(0, 8),
+        project: projectName(cwd, parentName),
+        peakTokens,
+        peakModel,
+        peakWindow,
+        peakPct: pyRound(peakPct, 1),
+        mapped: peakMapped,
+        unmapped: [...unmapped].sort(),
+        turns,
+        lastAt: lastAt || mtime,
+        compactions,
+        drops,
+        mtime,
+        size,
+    };
+}
+function sessionFiles(root, fs) {
+    if (!fs.isDir(root))
+        return [];
+    const found = [];
+    for (const dirEntry of fs.readdir(root)) {
+        const dirPath = path.join(root, dirEntry.name);
+        if (!fs.isDir(dirPath))
+            continue;
+        for (const fileEntry of fs.readdir(dirPath)) {
+            if (matchesGlobSuffix(fileEntry.name, ".jsonl")) {
+                found.push(path.join(dirPath, fileEntry.name));
+            }
+        }
+    }
+    return sortPaths(found);
+}
+function collect$1(root, previous, signal, fs, now) {
+    const cached = new Map();
+    for (const row of previous?.sessions ?? []) {
+        if (row.path)
+            cached.set(row.path, row);
+    }
+    const sessions = [];
+    const unmappedModels = new Set();
+    let parsed = 0;
+    for (const fp of sessionFiles(root, fs)) {
+        if (signal.aborted)
+            throw new Error("scan aborted");
+        const st = fs.stat(fp);
+        if (st === null)
+            continue;
+        const mtime = pyMtime({ sec: st.mtimeNs / 1000000000n, nsec: st.mtimeNs % 1000000000n });
+        const old = cached.get(fp);
+        if (old && old.mtime === mtime && old.size === st.size) {
+            sessions.push(old);
+            for (const m of old.unmapped)
+                unmappedModels.add(m);
+            continue;
+        }
+        const buffer = fs.readFile(fp);
+        if (buffer === null) {
+            if (old)
+                sessions.push(old);
+            continue;
+        }
+        parsed++;
+        const parentName = path.basename(path.dirname(fp));
+        const row = scanFile$1(buffer, mtime, st.size, path.basename(fp, ".jsonl"), parentName);
+        if (row === null)
+            continue;
+        row.path = fp;
+        sessions.push(row);
+        for (const m of row.unmapped)
+            unmappedModels.add(m);
+    }
+    return {
+        generatedAt: now() / 1000,
+        root: normalizeRoot(root),
+        scanned: sessions.length,
+        parsed,
+        unmappedModels: [...unmappedModels].sort(),
+        sessions,
+    };
+}
+
+/**
+ * Live "Memory footprint" payload (#52, 52b; 1.x `memory_footprint.py`), kind
+ * `memory-footprint`, capability `agent.scan.memory-footprint`. Producer only, and -- unlike
+ * every other scan in this file -- never cached: 1.x had no producer for this at all (it ran
+ * live in the dashboard build, "~8 stats per repo against small text files"), so the payload's
+ * nature changes from live-in-1.x to produced-on-request here, but it stays uncached because a
+ * cold run is kilobytes of I/O, not the ~940MB context-pressure reads (E4 plan §7.8).
+ *
+ * What it measures: the fixed 8-layer set Claude Code assembles into a session's preamble. Two
+ * layers are GLOBAL -- they load into every session in every repo -- the rest are per-repo. The
+ * repo set is 49a's `listRepos(reposRoot)` (every immediate child of `repos_root` with a `.git`
+ * entry), not a console-configured repo list (1.x had one; the agent doesn't) -- so `repo` and
+ * `name` are both the directory name, a disclosed change from 1.x's `owner/name` shape (E4 plan
+ * §7.2, §7.8's "the payload shape stays" exception).
+ *
+ * Tokens are ESTIMATED from bytes (~4 chars/token); the payload says so (`estimated: true`) so a
+ * consumer renders "≈". Transitive `@`-imports and `[[wikilinks]]` are NOT followed -- 1.x
+ * doesn't either, and expanding them would measure a different thing.
+ *
+ * Privacy: only sizes and line counts leave this module. File CONTENT never reaches the payload.
+ */
+const BYTES_PER_TOKEN = 4;
+const MEMORY_MAX_LINES = 200;
+const MAX_REPOS = 5;
+// A global preamble at or above this reads as worth trimming. Global layers are paid on EVERY
+// session in EVERY repo, so the threshold is deliberately lower than it would be for a single
+// project file -- the note is about recurring cost, not absolute size.
+const HEAVY_TOKENS = 4000;
+// Layers that load into every session regardless of repo. Kept as a set rather than a flag on
+// each row so the split can't drift between the scan and the summary.
+const GLOBAL = new Set(["enterprise", "user", "user-rules"]);
+/** The OS-specific managed-policy location -- Windows uses Program Files, the POSIX convention is
+ *  `/etc/claude-code`. `platform`/`env` are injected (unlike 1.x's own `os.name` check) so both
+ *  branches are testable regardless of which OS the test itself runs on. */
+function enterprisePath(platform, env) {
+    if (platform === "win32") {
+        return path.win32.join(env.ProgramFiles ?? String.raw `C:\Program Files`, "ClaudeCode", "CLAUDE.md");
+    }
+    return path.posix.join("/etc", "claude-code", "CLAUDE.md");
+}
+/** The `~/.claude/projects` folder name for a working directory: every `:`, `\` and `/` becomes a
+ *  hyphen -- `R:\repos\foo` -> `R--repos-foo` (the colon and the backslash each contribute one; a
+ *  Windows path has to resolve even when this runs on Linux, so the replacement is textual, not
+ *  routed through `node:path`, which would treat the backslash as an ordinary character there). */
+function projectDirName(root) {
+    return root.replace(/:/g, "-").replace(/\\/g, "-").replace(/\//g, "-");
+}
+/** Bytes -> approximate tokens. Deliberately crude, and labelled as such in the payload: the
+ *  question this answers is "is a layer out of budget", not an exact count. */
+function estimateTokens(nbytes) {
+    return Math.floor(Math.max(0, Math.trunc(nbytes)) / BYTES_PER_TOKEN);
+}
+/** `{bytes, lines}` for one file, or `null` when it can't be read. With `maxLines`, only the
+ *  first that many lines count towards both numbers -- used for `MEMORY.md`, which Claude Code
+ *  truncates at `MEMORY_MAX_LINES`; counting the whole file would overstate a layer the session
+ *  never actually loads. Line counting matches `readLines`'s semantics exactly (0x0A-terminated,
+ *  a final unterminated line still counts). */
+function measureFile(fs, p, maxLines) {
+    const buf = fs.readFile(p);
+    if (buf === null)
+        return null;
+    if (maxLines === undefined) {
+        return { bytes: buf.length, lines: readLines(buf).length };
+    }
+    const capped = readLines(buf).slice(0, maxLines);
+    return { bytes: capped.reduce((sum, line) => sum + line.length, 0), lines: capped.length };
+}
+function walkForSuffix(fs, dir, suffix, found) {
+    for (const entry of fs.readdir(dir)) {
+        const entryPath = path.join(dir, entry.name);
+        if (matchesGlobSuffix(entry.name, suffix))
+            found.push(entryPath);
+        if (fs.isDir(entryPath))
+            walkForSuffix(fs, entryPath, suffix, found);
+    }
+}
+/** `{bytes, lines, files}` for a rules directory (every `*.md` file under `root`, at any depth),
+ *  or `null` when `root` isn't a directory or holds no matching file -- a rules layer is either
+ *  fully present or not a row at all, never a zero-file row. */
+function measureGlob(fs, root, suffix) {
+    if (!fs.isDir(root))
+        return null;
+    const found = [];
+    walkForSuffix(fs, root, suffix, found);
+    let bytes = 0;
+    let lines = 0;
+    let files = 0;
+    for (const fp of sortPaths(found)) {
+        const got = measureFile(fs, fp);
+        if (got === null)
+            continue;
+        bytes += got.bytes;
+        lines += got.lines;
+        files++;
+    }
+    if (files === 0)
+        return null;
+    return { bytes, lines, files };
+}
+/** A payload row for one present layer, or `null` when the layer is absent. Absent layers are
+ *  dropped rather than rendered as zeroes: the payload lists what is actually loading. */
+function row(layer, filePath, got) {
+    if (got === null || got.bytes <= 0)
+        return null;
+    const base = {
+        layer,
+        path: filePath,
+        bytes: got.bytes,
+        lines: got.lines,
+        tokens: estimateTokens(got.bytes),
+        scope: GLOBAL.has(layer) ? "global" : "repo",
+    };
+    return got.files !== undefined ? { ...base, files: got.files } : base;
+}
+function byTokensDesc(a, b) {
+    return b.tokens - a.tokens;
+}
+/** The layers that load into every session in every repo, heaviest first. */
+function globalLayers(fs, home, platform, env) {
+    const ent = enterprisePath(platform, env);
+    const userClaude = path.join(home, ".claude", "CLAUDE.md");
+    const userRules = path.join(home, ".claude", "rules");
+    const rows = [
+        row("enterprise", ent, measureFile(fs, ent)),
+        row("user", userClaude, measureFile(fs, userClaude)),
+        row("user-rules", userRules, measureGlob(fs, userRules, ".md")),
+    ].filter((r) => r !== null);
+    return rows.sort(byTokensDesc);
+}
+/** The per-repo layers for one checkout, heaviest first. A `root` that doesn't exist simply
+ *  yields no rows (every `measureFile`/`measureGlob` call answers absent, not an error).
+ *  Unlike 1.x's `repo_layers(root, home)`, this takes no `home`: the auto-memory layer resolves
+ *  under the injected `projectsRoot` (52a's configured `claude_projects_dir`), never a hard-wired
+ *  `home/.claude/projects` -- see the module doc. */
+function repoLayers(fs, root, projectsRoot) {
+    const mem = path.join(projectsRoot, projectDirName(root), "memory", "MEMORY.md");
+    const projectClaude = path.join(root, "CLAUDE.md");
+    const projectAlt = path.join(root, ".claude", "CLAUDE.md");
+    const projectRules = path.join(root, ".claude", "rules");
+    const projectLocal = path.join(root, "CLAUDE.local.md");
+    const rows = [
+        row("project", projectClaude, measureFile(fs, projectClaude)),
+        row("project-alt", projectAlt, measureFile(fs, projectAlt)),
+        row("project-rules", projectRules, measureGlob(fs, projectRules, ".md")),
+        row("project-local", projectLocal, measureFile(fs, projectLocal)),
+        // Truncated to match what Claude Code actually loads -- see MEMORY_MAX_LINES.
+        row("auto-memory", mem, measureFile(fs, mem, MEMORY_MAX_LINES)),
+    ].filter((r) => r !== null);
+    return rows.sort(byTokensDesc);
+}
+/** The "Memory footprint" payload. `repos` is 49a's `listRepos(reposRoot).repos` -- every
+ *  immediate child of `repos_root` with a `.git` entry -- resolved by the caller (`scans/index.ts`)
+ *  before this runs, so this module stays pure over an already-resolved repo list. Checks
+ *  `signal.aborted` between repos, throwing `Error("scan aborted")` when set -- 1.x's live,
+ *  single-request-lifetime version never had an abort path to honour. */
+function overviewSummary(fs, repos, home, projectsRoot, platform, env, signal) {
+    const globRows = globalLayers(fs, home, platform, env);
+    const globalTokens = globRows.reduce((total, r) => total + r.tokens, 0);
+    const globalBytes = globRows.reduce((total, r) => total + r.bytes, 0);
+    const perRepo = [];
+    for (const repo of repos) {
+        if (signal.aborted)
+            throw new Error("scan aborted");
+        const layers = repoLayers(fs, repo.path, projectsRoot);
+        if (layers.length === 0)
+            continue; // a repo with no memory files isn't a row
+        perRepo.push({
+            repo: repo.name,
+            name: repo.name,
+            tokens: layers.reduce((total, r) => total + r.tokens, 0),
+            bytes: layers.reduce((total, r) => total + r.bytes, 0),
+            layers,
+        });
+    }
+    perRepo.sort((a, b) => b.tokens - a.tokens);
+    // The actionable note names ONE layer -- the heaviest global one, since that cost is paid on
+    // every session everywhere and is therefore the one worth trimming first. Silent below the
+    // threshold; a heavy per-repo layer never triggers it (that cost isn't paid everywhere).
+    const heavy = globRows.length > 0 && globalTokens >= HEAVY_TOKENS ? globRows[0] : null;
+    return {
+        available: true,
+        estimated: true,
+        bytesPerToken: BYTES_PER_TOKEN,
+        globalTokens,
+        globalBytes,
+        globalLayers: globRows,
+        repoTokens: perRepo.reduce((total, r) => total + r.tokens, 0),
+        repos: perRepo.slice(0, MAX_REPOS),
+        repoCount: perRepo.length,
+        reposConsidered: repos.length,
+        heavyLayer: heavy ? heavy.layer : null,
+        heavyTokens: heavy ? heavy.tokens : 0,
+        heavyPath: heavy ? heavy.path : null,
+        memoryMaxLines: MEMORY_MAX_LINES,
+    };
+}
+
+/**
+ * Per-session subagent token spend (#52, 52a; 1.x `subagent_cost.py`), kind `subagent-cost`,
+ * capability `agent.scan.subagent-cost`. Producer only -- the reader (`overview_summary`) is E7's.
+ *
+ * The dollar figure is an API-equivalent, not money spent: what these tokens would have cost at
+ * list API rates, so an unpriced model's tokens still count but its cost is excluded and the id is
+ * surfaced in `unpricedModels`.
+ *
+ * Privacy: deserialises exactly six things -- `type`, `timestamp`, `cwd`, `attributionAgent`,
+ * `message.{id,model,usage}`. `message.content` is never touched.
+ */
+const PRICES_AS_OF = "2026-07-25";
+const PRICES = {
+    "claude-opus-5": { in: 5.0, out: 25.0 },
+    "claude-opus-4-8": { in: 5.0, out: 25.0 },
+    "claude-opus-4-7": { in: 5.0, out: 25.0 },
+    "claude-opus-4-6": { in: 5.0, out: 25.0 },
+    "claude-fable-5": { in: 10.0, out: 50.0 },
+    "claude-sonnet-5": { in: 3.0, out: 15.0 },
+    "claude-sonnet-4-6": { in: 3.0, out: 15.0 },
+    "claude-haiku-4-5-20251001": { in: 1.0, out: 5.0 },
+};
+const CACHE_READ_MULT = 0.1;
+const CACHE_WRITE_5M_MULT = 1.25;
+const CACHE_WRITE_1H_MULT = 2.0;
+// A lower-cased startsWith on the FIRST attributionAgent seen -- Python's str.startswith accepts a
+// tuple of candidate prefixes; a match on either skips the whole file (return null/None).
+const SKIP_AGENT_PREFIXES = ["warmup", "acompact"];
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** USD-equivalent for one assistant turn, at list API rates. `0` for an unpriced model -- the
+ *  caller counts its tokens and surfaces the id instead of guessing. */
+function recordCost(model, usage) {
+    const rate = PRICES[model];
+    if (!rate)
+        return 0;
+    const creation = isPlainObject(usage.cache_creation) ? usage.cache_creation : {};
+    let w5 = pyIntOr0(creation.ephemeral_5m_input_tokens);
+    const w1 = pyIntOr0(creation.ephemeral_1h_input_tokens);
+    if (!(w5 || w1))
+        w5 = pyIntOr0(usage.cache_creation_input_tokens);
+    const fresh = pyIntOr0(usage.input_tokens);
+    const read = pyIntOr0(usage.cache_read_input_tokens);
+    const out = pyIntOr0(usage.output_tokens);
+    const dollars = fresh * rate.in +
+        read * rate.in * CACHE_READ_MULT +
+        w5 * rate.in * CACHE_WRITE_5M_MULT +
+        w1 * rate.in * CACHE_WRITE_1H_MULT +
+        out * rate.out;
+    return dollars / 1_000_000;
+}
+/** Token totals + API-equivalent cost for one subagent transcript, or `null` when it holds no
+ *  usage rows (or is machinery rather than delegated work). */
+function scanFile(fileBuffer, mtime, size, stem, parentName, fullPathComponents) {
+    let fresh = 0;
+    let read = 0;
+    let w5 = 0;
+    let w1 = 0;
+    let out = 0;
+    let cost = 0;
+    let turns = 0;
+    let agent = "";
+    let cwd = "";
+    let lastAt = 0;
+    const seenIds = new Set();
+    const models = new Set();
+    const unpriced = new Set();
+    for (const raw of readLines(fileBuffer)) {
+        if (!raw.includes(USAGE_MARK_BYTES))
+            continue;
+        const text = decodeLine(raw);
+        if (text === null)
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (!isPlainObject(rec) || rec.type !== "assistant")
+            continue;
+        const msg = rec.message;
+        if (!isPlainObject(msg))
+            continue;
+        const usage = msg.usage;
+        if (!isPlainObject(usage))
+            continue;
+        const model = String(msg.model || "");
+        if (model === "<synthetic>")
+            continue;
+        const mid = msg.id;
+        if (mid) {
+            const midStr = String(mid);
+            if (seenIds.has(midStr))
+                continue;
+            seenIds.add(midStr);
+        }
+        if (!agent) {
+            agent = String(rec.attributionAgent || "");
+            const lower = agent.toLowerCase();
+            if (SKIP_AGENT_PREFIXES.some((prefix) => lower.startsWith(prefix)))
+                return null;
+        }
+        if (!cwd)
+            cwd = String(rec.cwd || "");
+        const ts = parseTs(rec.timestamp);
+        if (ts > lastAt)
+            lastAt = ts;
+        const creation = isPlainObject(usage.cache_creation) ? usage.cache_creation : {};
+        let c5 = pyIntOr0(creation.ephemeral_5m_input_tokens);
+        const c1 = pyIntOr0(creation.ephemeral_1h_input_tokens);
+        if (!(c5 || c1))
+            c5 = pyIntOr0(usage.cache_creation_input_tokens);
+        fresh += pyIntOr0(usage.input_tokens);
+        read += pyIntOr0(usage.cache_read_input_tokens);
+        out += pyIntOr0(usage.output_tokens);
+        w5 += c5;
+        w1 += c1;
+        turns++;
+        if (model) {
+            models.add(model);
+            if (!(model in PRICES))
+                unpriced.add(model);
+        }
+        cost += recordCost(model, usage);
+    }
+    if (!turns)
+        return null;
+    return {
+        id: stem.split("agent-").join("").slice(0, 8),
+        agent: agent || "unknown",
+        project: projectName(cwd, parentName),
+        workflow: fullPathComponents.some((p) => p.startsWith("wf_")),
+        inputTokens: fresh,
+        cacheReadTokens: read,
+        cacheWrite5mTokens: w5,
+        cacheWrite1hTokens: w1,
+        outputTokens: out,
+        totalTokens: fresh + read + w5 + w1 + out,
+        costUsd: pyRound(cost, 6),
+        models: [...models].sort(),
+        unpriced: [...unpriced].sort(),
+        turns,
+        lastAt: lastAt || mtime,
+        mtime,
+        size,
+    };
+}
+/** Every entry named "agent-" + anything + ".jsonl", at any depth, under a
+ *  root, encoded-project, session, "subagents" directory (subagents at depth 3 exactly),
+ *  covering both the plain-Task layout and the nested Workflow one in a single walk. */
+function agentFiles(root, fs) {
+    if (!fs.isDir(root))
+        return [];
+    const found = [];
+    for (const encEntry of fs.readdir(root)) {
+        const encPath = path.join(root, encEntry.name);
+        if (!fs.isDir(encPath))
+            continue;
+        for (const sessionEntry of fs.readdir(encPath)) {
+            const sessionPath = path.join(encPath, sessionEntry.name);
+            if (!fs.isDir(sessionPath))
+                continue;
+            const subagentsPath = path.join(sessionPath, "subagents");
+            if (!fs.isDir(subagentsPath))
+                continue;
+            walkForAgentFiles(subagentsPath, fs, found);
+        }
+    }
+    return sortPaths(found);
+}
+function walkForAgentFiles(dir, fs, found) {
+    for (const entry of fs.readdir(dir)) {
+        const entryPath = path.join(dir, entry.name);
+        if (matchesGlobPrefixSuffix(entry.name, "agent-", ".jsonl")) {
+            found.push(entryPath);
+        }
+        if (fs.isDir(entryPath)) {
+            walkForAgentFiles(entryPath, fs, found);
+        }
+    }
+}
+function collect(root, previous, signal, fs, now) {
+    const cached = new Map();
+    for (const row of previous?.agents ?? []) {
+        if (row.path)
+            cached.set(row.path, row);
+    }
+    const agents = [];
+    const unpricedModels = new Set();
+    let parsed = 0;
+    for (const fp of agentFiles(root, fs)) {
+        if (signal.aborted)
+            throw new Error("scan aborted");
+        const st = fs.stat(fp);
+        if (st === null)
+            continue;
+        const mtime = pyMtime({ sec: st.mtimeNs / 1000000000n, nsec: st.mtimeNs % 1000000000n });
+        const old = cached.get(fp);
+        if (old && old.mtime === mtime && old.size === st.size) {
+            agents.push(old);
+            for (const m of old.unpriced)
+                unpricedModels.add(m);
+            continue;
+        }
+        const buffer = fs.readFile(fp);
+        if (buffer === null) {
+            if (old)
+                agents.push(old);
+            continue;
+        }
+        parsed++;
+        const parentName = path.basename(path.dirname(fp));
+        const relComponents = fp.split(/[\\/]/).filter((p) => p !== "");
+        const row = scanFile(buffer, mtime, st.size, path.basename(fp, ".jsonl"), parentName, relComponents);
+        if (row === null)
+            continue;
+        row.path = fp;
+        agents.push(row);
+        for (const m of row.unpriced)
+            unpricedModels.add(m);
+    }
+    return {
+        generatedAt: now() / 1000,
+        root: normalizeRoot(root),
+        scanned: agents.length,
+        parsed,
+        pricesAsOf: PRICES_AS_OF,
+        unpricedModels: [...unpricedModels].sort(),
+        agents,
+    };
+}
+
+var scriptText = "<#\n.SYNOPSIS\n    Inventory the language toolchains installed on this machine (Windows + WSL)\n    into the artifact-console store, where the dashboard shows it and the\n    claude-memory-sync git log is its running history.\n\n.DESCRIPTION\n    Probes a curated catalog of toolchain executables (language runtimes,\n    compilers, package managers, version managers, build tools, VCS / container /\n    infra CLIs) on the Windows side and inside each WSL distro, capturing each\n    tool's version, official Home + GitHub links, path, and best-effort install\n    source. Also dumps globally-installed packages (npm -g, pipx, uv, cargo, gem,\n    go). On a real change it writes toolchain-inventory-<machine>.md into the\n    artifacts store -- one file per box, since what is installed here is a\n    per-machine fact and the store is shared across machines (issue #231) --\n    and renders it via build.py, which lands it into the memory repo; a\n    no-change run does nothing. The script never writes into its own directory\n    (scratch/state go to %TEMP% / %LOCALAPPDATA%), so it is safe to keep under a\n    git repo (artifacts-console/artifact-console/data) -- and, since #320, inside the\n    installed package.\n\n.PARAMETER IncludeEditors\n    Also probe editors / IDEs (VS Code, Neovim, Vim, Emacs, Sublime, Helix).\n    Off by default. To turn it on permanently, either pass this switch or flip\n    $IncludeEditorsDefault below to $true.\n\n.PARAMETER WslDistro\n    WSL distro to probe. Defaults to 'Ubuntu'. Pass '' (empty) to skip WSL.\n\n.PARAMETER SourcesDir\n    The artifact store root the report is written under. Derived from the console's\n    config when omitted -- it used to be a hardcoded `R:\\repos\\claude-memory-sync\\\n    artifacts`, correct on one machine and resolving on a second only through a\n    junction (issue #231).\n\n.PARAMETER PythonExe\n    The console's own python.exe, used for both the store-root lookup and the\n    build.py render. Passed by sched_spec.job_argv (sys.executable) and by\n    Register-InventoryTask.ps1 (resolved beside pythonw.exe) -- bare `python` on\n    PATH is not necessarily the console's interpreter (issue #632), especially\n    under pipx. Falls back to `python` on PATH when omitted, so a hand run still\n    works.\n\n.PARAMETER OutFile\n    Write the report here instead of the store (for local testing). The store\n    render/land is skipped when you pass a path -- what would be rendered is the STORE's\n    copy of the report, which this run did not write. An empty value is the same as\n    omitting it: the report goes to the store, and that run does render.\n\n.PARAMETER SshTargets\n    `alias=user@host;alias2=user@host2` -- Linux hosts to probe over key-based SSH\n    alongside Windows + WSL (issue #715), one `toolchain-inventory-<alias>.md` per alias.\n    Empty (the default) probes no SSH hosts. An unreachable host is isolated: its previous\n    report is left untouched, every other target (local, WSL, remaining hosts) still\n    publishes, and the process exits 2 so the task's Last Result shows it.\n\n.PARAMETER NoRender\n    Write the report but don't render/land it into artifact-console.\n\n.PARAMETER NoSync\n    Render into the docroot but don't land into the memory repo (build.py\n    --no-sync); the hourly ClaudeMemorySync task still commits it later.\n\n.EXAMPLE\n    .\\Get-ToolchainInventory.ps1\n.EXAMPLE\n    .\\Get-ToolchainInventory.ps1 -IncludeEditors\n.EXAMPLE\n    .\\Get-ToolchainInventory.ps1 -OutFile $env:TEMP\\inv.md   # local test, no render\n#>\n[CmdletBinding()]\nparam(\n    [switch]$IncludeEditors,\n    [string]$WslDistro = 'Ubuntu',\n    [string]$SourcesDir = '',\n    [string]$PythonExe = '',\n    [string]$OutFile,\n    [string]$SshTargets = '',\n    [switch]$NoRender,\n    [switch]$NoSync\n)\n\n# ---------------------------------------------------------------------------\n# Editable defaults -- change these instead of the code below.\n# Flip $IncludeEditorsDefault to $true to always include editors/IDEs.\n# ---------------------------------------------------------------------------\n$IncludeEditorsDefault = $false\n\n# The report's home is the artifact-console store. On a change the script writes its\n# report there and renders it via build.py, which also lands it in the claude-memory-sync\n# repo, whose git log IS the history.\n#\n# This payload ships INSIDE the console (artifact-console/data/), so the console dir --\n# where build.py and scheduled_tasks.py live -- is simply this script's PARENT. #320 (PR\n# #330) moved the file here from the repo's PowerShell/ drawer as a pure rename (R100),\n# leaving the drawer-era `Join-Path (Split-Path $PSScriptRoot -Parent) 'artifact-console'`\n# resolving to a doubled artifact-console/artifact-console that has never existed. The\n# render guard below tests that path, so its condition became permanently TRUE and the\n# render branch unreachable: a run with something to publish wrote its report to the store,\n# printed a yellow skip and exited 0. (A no-change run returns earlier still and is not\n# affected.) So the .md kept reaching the store, but nothing rendered it into the docroot\n# and nothing recorded it for landing -- sync_memory stages only the paths build.py records,\n# never a blanket add -- so no automatic `chore(artifacts): sync Toolchain-Inventory/...`\n# commit has landed since, every later touch made by hand. (The last one is 2026-07-20, which\n# is an outer bound rather than a fingerprint: #231's per-machine rename sits between it and\n# this move.) The registrar's half of the\n# same rename was caught in #334; this was the other half, and it sat unnoticed for a month\n# because the skip message named neither the path nor which half was missing.\n#\n# The parent is right in a WHEEL too, and not by luck: data/ installs as the\n# `artifact_console_data` package while the modules install FLAT beside it, so\n# site-packages/artifact_console_data/.. is site-packages/, which holds build.py.\n#\n# The store ROOT is not spelled out here any more (issue #231). It was\n# `R:\\repos\\claude-memory-sync\\artifacts`: right on the box it was written on, and on a\n# second machine right only by way of a junction. Register-InventoryTask.ps1 passes the\n# config-derived value; a hand run asks the console for the same one.\n$ArtifactConsoleDir = Split-Path $PSScriptRoot -Parent\n$ArtifactCategory   = 'Toolchain-Inventory'\n\n$ErrorActionPreference = 'Stop'\n$includeEd = $IncludeEditors.IsPresent -or $IncludeEditorsDefault\n\n# The interpreter for BOTH Python call sites below. `python` on PATH is not\n# necessarily the console's own interpreter -- under pipx it never is (#632) --\n# so a caller that knows the right one (sched_spec.job_argv, the registrar) passes\n# it explicitly. PATH is only the fallback, for a hand run with nothing supplied.\n$pyExe = if ($PythonExe) { $PythonExe } else { 'python' }\n\n# Needed before the output path is chosen, not just in the report body: this report\n# describes ONE machine, so the machine is part of its filename.\n$hostName = [System.Net.Dns]::GetHostName()\n\nif (-not $SourcesDir -and -not $OutFile) {\n    $jobPaths = Join-Path $ArtifactConsoleDir 'scheduled_tasks.py'\n    try {\n        # Same native-exit trap as the render below: a python that RUNS and exits non-zero\n        # does not throw, so without this the catch could never fire on the commonest\n        # failures -- a traceback, an unconfigured store, or the Windows App Execution\n        # Alias stub, which is on PATH and exits non-zero rather than being absent.\n        # ConvertFrom-Json would just yield nothing, $SourcesDir would end up empty, and\n        # the reason would never be printed. (A genuinely missing command is the one case\n        # that always threw: CommandNotFoundException, which this catch already handled.)\n        $jobPathsJson = & $pyExe $jobPaths --job-paths toolchain-inventory\n        if ($LASTEXITCODE -ne 0) { throw \"scheduled_tasks.py --job-paths exited $LASTEXITCODE\" }\n        $SourcesDir = ($jobPathsJson | ConvertFrom-Json).args.SourcesDir\n    } catch {\n        Write-Host \"! could not ask the console for the store root: $($_.Exception.Message)\" -ForegroundColor Yellow\n    }\n}\n\n$ArtifactSourcesDir = $SourcesDir\n\n# This script lives in a git repo (artifacts-console) -- and, since #320, ships inside the\n# installed package, where writing would be worse still -- so it must NEVER write into its\n# own directory. Scratch (probe files) and state (last-run) go to out-of-repo temp /\n# local-appdata; the report itself goes to the artifacts store.\n$tmpDir   = Join-Path ([IO.Path]::GetTempPath()) 'toolchain-inventory'\n$stateDir = Join-Path $env:LOCALAPPDATA 'toolchain-inventory'\nNew-Item -ItemType Directory -Force -Path $tmpDir, $stateDir | Out-Null\n\n# One file per machine. This report is a per-machine fact -- what is installed on THIS\n# box -- and it used to be written under a single machine-agnostic name into a git-synced\n# store shared by every machine. With the weekly task registered on two boxes, each run\n# overwrote the other's and the category became a flip-flop: every run a large diff\n# reverting the previous one, so the git log that is supposed to BE the history recorded\n# no machine's toolchain drift legibly (issue #231). Keyed by hostname, each machine owns\n# one file, diffs stay meaningful, and no coordination between boxes is needed.\n$machine  = ($hostName -replace '[^A-Za-z0-9._-]', '-')\n$fileName = \"toolchain-inventory-$machine.md\"\n\n$storeDir       = if ($ArtifactSourcesDir) { Join-Path $ArtifactSourcesDir $ArtifactCategory } else { '' }\n$storeAvailable = [bool]$ArtifactSourcesDir -and (Test-Path $ArtifactSourcesDir)\nif (-not $OutFile) {\n    if ($storeAvailable) {\n        New-Item -ItemType Directory -Force -Path $storeDir | Out-Null\n        $OutFile = Join-Path $storeDir $fileName\n    } else {\n        $OutFile = Join-Path $stateDir $fileName\n        Write-Host \"! artifacts store not found; writing locally to $OutFile\" -ForegroundColor Yellow\n    }\n}\n\n# ---------------------------------------------------------------------------\n# Tool catalog. One row per tool:\n#   Category | Name | Exe | Ver (arg array) | Alt (fallback arg array or $null)\n# Add a row here to track a new tool -- it is picked up on both Windows and WSL.\n# ---------------------------------------------------------------------------\n$catalog = @(\n    # --- Language runtimes & compilers ---\n    @{ Cat='Languages'; Name='Node.js';     Exe='node';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='Deno';        Exe='deno';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='Bun';         Exe='bun';     Ver=@('--version') }\n    @{ Cat='Languages'; Name='Python';      Exe='python';  Ver=@('--version') }\n    @{ Cat='Languages'; Name='Python3';     Exe='python3'; Ver=@('--version') }\n    @{ Cat='Languages'; Name='Py launcher'; Exe='py';      Ver=@('--version') }\n    @{ Cat='Languages'; Name='Go';          Exe='go';      Ver=@('version') }\n    @{ Cat='Languages'; Name='Rust (rustc)';Exe='rustc';   Ver=@('--version') }\n    @{ Cat='Languages'; Name='Java';        Exe='java';    Ver=@('-version') }\n    @{ Cat='Languages'; Name='javac (JDK)'; Exe='javac';   Ver=@('-version') }\n    @{ Cat='Languages'; Name='.NET SDK';    Exe='dotnet';  Ver=@('--version') }\n    @{ Cat='Languages'; Name='Ruby';        Exe='ruby';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='PHP';         Exe='php';     Ver=@('--version') }\n    @{ Cat='Languages'; Name='Lua';         Exe='lua';     Ver=@('-v') }\n    @{ Cat='Languages'; Name='LuaJIT';      Exe='luajit';  Ver=@('-v') }\n    @{ Cat='Languages'; Name='Perl';        Exe='perl';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='GCC';         Exe='gcc';     Ver=@('--version') }\n    @{ Cat='Languages'; Name='G++';         Exe='g++';     Ver=@('--version') }\n    @{ Cat='Languages'; Name='Clang';       Exe='clang';   Ver=@('--version') }\n    @{ Cat='Languages'; Name='Zig';         Exe='zig';     Ver=@('version') }\n    @{ Cat='Languages'; Name='Kotlin';      Exe='kotlin';  Ver=@('-version') }\n    @{ Cat='Languages'; Name='Scala';       Exe='scala';   Ver=@('-version') }\n    @{ Cat='Languages'; Name='Swift';       Exe='swift';   Ver=@('--version') }\n    @{ Cat='Languages'; Name='GHC (Haskell)';Exe='ghc';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='Elixir';      Exe='elixir';  Ver=@('--version') }\n    @{ Cat='Languages'; Name='Julia';       Exe='julia';   Ver=@('--version') }\n    @{ Cat='Languages'; Name='R';           Exe='R';       Ver=@('--version') }\n    @{ Cat='Languages'; Name='Dart';        Exe='dart';    Ver=@('--version') }\n    @{ Cat='Languages'; Name='Nim';         Exe='nim';     Ver=@('--version') }\n    @{ Cat='Languages'; Name='OCaml';       Exe='ocaml';   Ver=@('-version') }\n\n    # --- Package managers ---\n    @{ Cat='Package managers'; Name='npm';      Exe='npm';      Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Yarn';     Exe='yarn';     Ver=@('--version') }\n    @{ Cat='Package managers'; Name='pnpm';     Exe='pnpm';     Ver=@('--version') }\n    @{ Cat='Package managers'; Name='pip';      Exe='pip';      Ver=@('--version') }\n    @{ Cat='Package managers'; Name='pipx';     Exe='pipx';     Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Poetry';   Exe='poetry';   Ver=@('--version') }\n    @{ Cat='Package managers'; Name='uv';       Exe='uv';       Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Conda';    Exe='conda';    Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Cargo';    Exe='cargo';    Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Gem';      Exe='gem';      Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Bundler';  Exe='bundle';   Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Composer'; Exe='composer'; Ver=@('--version') }\n    @{ Cat='Package managers'; Name='Maven';    Exe='mvn';      Ver=@('-version') }\n    @{ Cat='Package managers'; Name='Gradle';   Exe='gradle';   Ver=@('--version') }\n    @{ Cat='Package managers'; Name='LuaRocks'; Exe='luarocks'; Ver=@('--version') }\n\n    # --- Version managers ---\n    @{ Cat='Version managers'; Name='nvm';    Exe='nvm';    Ver=@('--version'); Alt=@('version') }\n    @{ Cat='Version managers'; Name='fnm';    Exe='fnm';    Ver=@('--version') }\n    @{ Cat='Version managers'; Name='Volta';  Exe='volta';  Ver=@('--version') }\n    @{ Cat='Version managers'; Name='pyenv';  Exe='pyenv';  Ver=@('--version') }\n    @{ Cat='Version managers'; Name='rustup'; Exe='rustup'; Ver=@('--version') }\n    @{ Cat='Version managers'; Name='rbenv';  Exe='rbenv';  Ver=@('--version') }\n    @{ Cat='Version managers'; Name='asdf';   Exe='asdf';   Ver=@('--version') }\n    @{ Cat='Version managers'; Name='SDKMAN'; Exe='sdk';    Ver=@('version') }\n\n    # --- Build tools & runners ---\n    @{ Cat='Build tools'; Name='Make';    Exe='make';    Ver=@('--version') }\n    @{ Cat='Build tools'; Name='CMake';   Exe='cmake';   Ver=@('--version') }\n    @{ Cat='Build tools'; Name='Ninja';   Exe='ninja';   Ver=@('--version') }\n    @{ Cat='Build tools'; Name='Meson';   Exe='meson';   Ver=@('--version') }\n    @{ Cat='Build tools'; Name='Bazel';   Exe='bazel';   Ver=@('--version') }\n    @{ Cat='Build tools'; Name='just';    Exe='just';    Ver=@('--version') }\n    @{ Cat='Build tools'; Name='MSBuild'; Exe='msbuild'; Ver=@('-version') }\n    @{ Cat='Build tools'; Name='Ant';     Exe='ant';     Ver=@('-version') }\n\n    # --- VCS, containers & infra ---\n    @{ Cat='VCS & infra'; Name='Git';            Exe='git';            Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='GitHub CLI';     Exe='gh';             Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='Docker';         Exe='docker';         Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='Docker Compose'; Exe='docker-compose'; Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='Podman';         Exe='podman';         Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='kubectl';        Exe='kubectl';        Ver=@('version','--client') }\n    @{ Cat='VCS & infra'; Name='Helm';           Exe='helm';           Ver=@('version','--short') }\n    @{ Cat='VCS & infra'; Name='Terraform';      Exe='terraform';      Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='OpenTofu';       Exe='tofu';           Ver=@('--version') }\n    @{ Cat='VCS & infra'; Name='Ansible';        Exe='ansible';        Ver=@('--version') }\n    # cloudflared -- added for #715: nitro/nucbox both front their consoles through a\n    # Cloudflare Tunnel, and the epic's exit criterion names it explicitly.\n    @{ Cat='VCS & infra'; Name='cloudflared';    Exe='cloudflared';    Ver=@('--version') }\n)\n\n$editorCatalog = @(\n    @{ Cat='Editors'; Name='VS Code';  Exe='code';  Ver=@('--version') }\n    @{ Cat='Editors'; Name='Neovim';   Exe='nvim';  Ver=@('--version') }\n    @{ Cat='Editors'; Name='Vim';      Exe='vim';   Ver=@('--version') }\n    @{ Cat='Editors'; Name='Emacs';    Exe='emacs'; Ver=@('--version') }\n    @{ Cat='Editors'; Name='Sublime';  Exe='subl';  Ver=@('--version') }\n    @{ Cat='Editors'; Name='Helix';    Exe='hx';    Ver=@('--version') }\n)\nif ($includeEd) { $catalog += $editorCatalog }\n\n# Fixed category display order.\n$catOrder = @('Languages','Package managers','Version managers','Build tools','VCS & infra','Editors')\n\n# ---------------------------------------------------------------------------\n# Reference links per tool (keyed by catalog Name): official Home + GitHub repo\n# (owner/repo; URL derived). Blank where none is canonical. Add a tool here when\n# you add it to $catalog. Rendered as the Home / GitHub columns.\n# ---------------------------------------------------------------------------\n$refLinks = @{\n    # Languages\n    'Node.js'       = @{ Home='https://nodejs.org';               Repo='nodejs/node' }\n    'Deno'          = @{ Home='https://deno.com';                 Repo='denoland/deno' }\n    'Bun'           = @{ Home='https://bun.sh';                   Repo='oven-sh/bun' }\n    'Python'        = @{ Home='https://python.org';               Repo='python/cpython' }\n    'Python3'       = @{ Home='https://python.org';               Repo='python/cpython' }\n    'Py launcher'   = @{ Home='https://docs.python.org/using/windows.html'; Repo='python/cpython' }\n    'Go'            = @{ Home='https://go.dev';                   Repo='golang/go' }\n    'Rust (rustc)'  = @{ Home='https://rust-lang.org';            Repo='rust-lang/rust' }\n    'Java'          = @{ Home='https://openjdk.org';              Repo='openjdk/jdk' }\n    'javac (JDK)'   = @{ Home='https://openjdk.org';              Repo='openjdk/jdk' }\n    '.NET SDK'      = @{ Home='https://dotnet.microsoft.com';     Repo='dotnet/sdk' }\n    'Ruby'          = @{ Home='https://ruby-lang.org';            Repo='ruby/ruby' }\n    'PHP'           = @{ Home='https://php.net';                  Repo='php/php-src' }\n    'Lua'           = @{ Home='https://lua.org';                  Repo='lua/lua' }\n    'LuaJIT'        = @{ Home='https://luajit.org';               Repo='LuaJIT/LuaJIT' }\n    'Perl'          = @{ Home='https://perl.org';                 Repo='Perl/perl5' }\n    'GCC'           = @{ Home='https://gcc.gnu.org';              Repo='gcc-mirror/gcc' }\n    'G++'           = @{ Home='https://gcc.gnu.org';              Repo='gcc-mirror/gcc' }\n    'Clang'         = @{ Home='https://clang.llvm.org';           Repo='llvm/llvm-project' }\n    'Zig'           = @{ Home='https://ziglang.org';              Repo='ziglang/zig' }\n    'Kotlin'        = @{ Home='https://kotlinlang.org';           Repo='JetBrains/kotlin' }\n    'Scala'         = @{ Home='https://scala-lang.org';           Repo='scala/scala' }\n    'Swift'         = @{ Home='https://swift.org';                Repo='apple/swift' }\n    'GHC (Haskell)' = @{ Home='https://haskell.org';              Repo='' }\n    'Elixir'        = @{ Home='https://elixir-lang.org';          Repo='elixir-lang/elixir' }\n    'Julia'         = @{ Home='https://julialang.org';            Repo='JuliaLang/julia' }\n    'R'             = @{ Home='https://r-project.org';            Repo='' }\n    'Dart'          = @{ Home='https://dart.dev';                 Repo='dart-lang/sdk' }\n    'Nim'           = @{ Home='https://nim-lang.org';             Repo='nim-lang/Nim' }\n    'OCaml'         = @{ Home='https://ocaml.org';                Repo='ocaml/ocaml' }\n    # Package managers\n    'npm'           = @{ Home='https://npmjs.com';                Repo='npm/cli' }\n    'Yarn'          = @{ Home='https://yarnpkg.com';              Repo='yarnpkg/berry' }\n    'pnpm'          = @{ Home='https://pnpm.io';                  Repo='pnpm/pnpm' }\n    'pip'           = @{ Home='https://pip.pypa.io';              Repo='pypa/pip' }\n    'pipx'          = @{ Home='https://pipx.pypa.io';             Repo='pypa/pipx' }\n    'Poetry'        = @{ Home='https://python-poetry.org';        Repo='python-poetry/poetry' }\n    'uv'            = @{ Home='https://docs.astral.sh/uv';        Repo='astral-sh/uv' }\n    'Conda'         = @{ Home='https://conda.io';                 Repo='conda/conda' }\n    'Cargo'         = @{ Home='https://doc.rust-lang.org/cargo';  Repo='rust-lang/cargo' }\n    'Gem'           = @{ Home='https://rubygems.org';             Repo='rubygems/rubygems' }\n    'Bundler'       = @{ Home='https://bundler.io';               Repo='rubygems/rubygems' }\n    'Composer'      = @{ Home='https://getcomposer.org';          Repo='composer/composer' }\n    'Maven'         = @{ Home='https://maven.apache.org';         Repo='apache/maven' }\n    'Gradle'        = @{ Home='https://gradle.org';               Repo='gradle/gradle' }\n    'LuaRocks'      = @{ Home='https://luarocks.org';             Repo='luarocks/luarocks' }\n    # Version managers\n    'nvm'           = @{ Home='';                                 Repo='nvm-sh/nvm' }\n    'fnm'           = @{ Home='';                                 Repo='Schniz/fnm' }\n    'Volta'         = @{ Home='https://volta.sh';                 Repo='volta-cli/volta' }\n    'pyenv'         = @{ Home='';                                 Repo='pyenv/pyenv' }\n    'rustup'        = @{ Home='https://rustup.rs';                Repo='rust-lang/rustup' }\n    'rbenv'         = @{ Home='';                                 Repo='rbenv/rbenv' }\n    'asdf'          = @{ Home='https://asdf-vm.com';              Repo='asdf-vm/asdf' }\n    'SDKMAN'        = @{ Home='https://sdkman.io';                Repo='sdkman/sdkman-cli' }\n    # Build tools\n    'Make'          = @{ Home='https://gnu.org/software/make';    Repo='' }\n    'CMake'         = @{ Home='https://cmake.org';                Repo='Kitware/CMake' }\n    'Ninja'         = @{ Home='https://ninja-build.org';          Repo='ninja-build/ninja' }\n    'Meson'         = @{ Home='https://mesonbuild.com';           Repo='mesonbuild/meson' }\n    'Bazel'         = @{ Home='https://bazel.build';              Repo='bazelbuild/bazel' }\n    'just'          = @{ Home='https://just.systems';             Repo='casey/just' }\n    'MSBuild'       = @{ Home='https://learn.microsoft.com/visualstudio/msbuild/msbuild'; Repo='dotnet/msbuild' }\n    'Ant'           = @{ Home='https://ant.apache.org';           Repo='apache/ant' }\n    # VCS & infra\n    'Git'            = @{ Home='https://git-scm.com';             Repo='git/git' }\n    'GitHub CLI'     = @{ Home='https://cli.github.com';          Repo='cli/cli' }\n    'Docker'         = @{ Home='https://docker.com';              Repo='docker/cli' }\n    'Docker Compose' = @{ Home='https://docs.docker.com/compose'; Repo='docker/compose' }\n    'Podman'         = @{ Home='https://podman.io';               Repo='containers/podman' }\n    'kubectl'        = @{ Home='https://kubernetes.io';           Repo='kubernetes/kubernetes' }\n    'Helm'           = @{ Home='https://helm.sh';                 Repo='helm/helm' }\n    'Terraform'      = @{ Home='https://terraform.io';            Repo='hashicorp/terraform' }\n    'OpenTofu'       = @{ Home='https://opentofu.org';            Repo='opentofu/opentofu' }\n    'Ansible'        = @{ Home='https://ansible.com';             Repo='ansible/ansible' }\n    'cloudflared'    = @{ Home='https://developers.cloudflare.com/cloudflared'; Repo='cloudflare/cloudflared' }\n    # Editors\n    'VS Code'        = @{ Home='https://code.visualstudio.com';   Repo='microsoft/vscode' }\n    'Neovim'         = @{ Home='https://neovim.io';               Repo='neovim/neovim' }\n    'Vim'            = @{ Home='https://vim.org';                 Repo='vim/vim' }\n    'Emacs'          = @{ Home='https://gnu.org/software/emacs';  Repo='' }\n    'Sublime'        = @{ Home='https://sublimetext.com';         Repo='' }\n    'Helix'          = @{ Home='https://helix-editor.com';        Repo='helix-editor/helix' }\n}\n\n# ---------------------------------------------------------------------------\n# Helpers\n# ---------------------------------------------------------------------------\nfunction Get-CleanVersion([string]$raw) {\n    if (-not $raw) { return '' }\n    $line = ($raw -split \"`n\" | Where-Object { $_.Trim() -ne '' } | Select-Object -First 1)\n    if (-not $line) { return '' }\n    $line = $line.Trim()\n    $m = [regex]::Match($line, '\\d+\\.\\d+(\\.\\d+){0,3}')\n    if ($m.Success) { return $m.Value }\n    if ($line.Length -gt 48) { return $line.Substring(0,48) }\n    return $line\n}\n\nfunction Get-WinSource([string]$path) {\n    if (-not $path) { return '' }\n    $p = $path.ToLower()\n    if ($p -like '*\\scoop\\*')                     { return 'scoop' }\n    if ($p -like '*\\chocolatey\\*')                { return 'choco' }\n    if ($p -like '*\\winget*' -or\n        $p -like '*\\windowsapps\\*')               { return 'winget/store' }\n    if ($p -like '*\\.cargo\\*')                    { return 'cargo' }\n    if ($p -like '*\\nvm*')                        { return 'nvm' }\n    if ($p -like '*\\program files*')              { return 'installer' }\n    if ($p -like '*\\appdata\\local\\programs\\*')    { return 'user-install' }\n    return ''\n}\n\nfunction Get-WslSource([string]$path) {\n    if (-not $path) { return '' }\n    if ($path -like '*/.cargo/*')  { return 'cargo' }\n    if ($path -like '*/.local/*')  { return 'pip/pipx' }\n    if ($path -like '*/.nvm/*')    { return 'nvm' }\n    if ($path -like '*/snap/*')    { return 'snap' }\n    if ($path -like '/usr/*' -or $path -like '/bin/*') { return 'apt/system' }\n    return ''\n}\n\n# Probe a single tool on the Windows side. Returns a result hashtable or $null.\nfunction Get-WinToolInfo($tool) {\n    # Only real executables / scripts -- never PS aliases, functions, or cmdlets\n    # (e.g. `R` is the built-in alias for Invoke-History, not the R language).\n    $cmd = Get-Command $tool.Exe -CommandType Application,ExternalScript -ErrorAction SilentlyContinue |\n           Select-Object -First 1\n    if (-not $cmd) { return $null }\n    $path = if ($cmd.Source) { $cmd.Source } else { $cmd.Name }\n    $raw = ''\n    try { $raw = (& $tool.Exe @($tool.Ver) 2>&1 | Out-String) } catch { $raw = '' }\n    $ver = Get-CleanVersion $raw\n    if (-not $ver -and $tool.Alt) {\n        try { $raw = (& $tool.Exe @($tool.Alt) 2>&1 | Out-String) } catch { $raw = '' }\n        $ver = Get-CleanVersion $raw\n    }\n    return @{ Cat=$tool.Cat; Name=$tool.Name; Version=$ver; Path=$path; Source=(Get-WinSource $path) }\n}\n\nfunction Format-HomeCell($homeUrl) {\n    if (-not $homeUrl) { return '-' }\n    $label = ($homeUrl -replace '^https?://','') -replace '/$',''\n    return \"[$label]($homeUrl)\"\n}\nfunction Format-RepoCell($repo) {\n    if (-not $repo) { return '-' }\n    return \"[$repo](https://github.com/$repo)\"\n}\nfunction Format-Table-Md($rows) {\n    if (-not $rows -or $rows.Count -eq 0) { return \"_none found_`n\" }\n    $sb = New-Object System.Text.StringBuilder\n    [void]$sb.AppendLine('| Tool | Version | Home | GitHub | Source | Path |')\n    [void]$sb.AppendLine('|------|---------|------|--------|--------|------|')\n    foreach ($r in ($rows | Sort-Object Name)) {\n        $ver      = if ($r.Version) { $r.Version } else { '(present)' }\n        $src      = if ($r.Source) { $r.Source } else { '-' }\n        $ref      = $refLinks[$r.Name]\n        $homeCell = Format-HomeCell $ref.Home\n        $ghCell   = Format-RepoCell $ref.Repo\n        [void]$sb.AppendLine(\"| $($r.Name) | $ver | $homeCell | $ghCell | $src | ``$($r.Path)`` |\")\n    }\n    return $sb.ToString()\n}\n\nfunction Format-SideSection($rows) {\n    $sb = New-Object System.Text.StringBuilder\n    foreach ($cat in $catOrder) {\n        $catRows = $rows | Where-Object { $_.Cat -eq $cat }\n        if (-not $catRows) { continue }\n        [void]$sb.AppendLine(\"### $cat`n\")\n        [void]$sb.AppendLine((Format-Table-Md $catRows))\n    }\n    return $sb.ToString()\n}\n\n# ---------------------------------------------------------------------------\n# \"Unrecognized dev tool on PATH\" heads-up. Scans the dirs where dev package\n# managers drop user-installed CLIs (cargo/go/dotnet/npm/scoop/.local) and flags\n# any executable whose name isn't a catalogued tool or a known companion binary\n# of one. High-signal by construction: it never looks in system dirs, so a hit\n# is almost always a real tool you installed but haven't catalogued yet.\n# ---------------------------------------------------------------------------\n$knownExe = @{}\nforeach ($t in ($catalog + $editorCatalog)) { $knownExe[$t.Exe.ToLower()] = $true }\n\n# Auxiliary binaries that ship WITH a catalogued tool -- not \"new tools\".\n$companionExe = @{}\nforeach ($n in @(\n    'rustfmt','rustdoc','clippy-driver','cargo-clippy','cargo-fmt','cargo-miri',\n    'rust-gdb','rust-gdbgui','rust-lldb','rust-analyzer',\n    'gofmt','godoc','npx','pnpx','corepack','yarnpkg',\n    'uvx','uvw','rls',\n    'pydoc','2to3','idle','wheel','activate',\n    'php-cgi','phpdbg','erl','epmd','escript','iex','mix','rebar3',\n    'bundler','rdoc','ri'\n)) { $companionExe[$n] = $true }\n\nfunction Test-KnownTool([string]$name) {\n    $n = $name.ToLower()\n    if ($knownExe.ContainsKey($n) -or $companionExe.ContainsKey($n)) { return $true }\n    # version-suffixed interpreters/tools: python3.12, pip3, ruby3.3, perl5.40, node18, php8.3\n    if ($n -match '^(python|pip|ruby|perl|php|node|lua|luajit|clang|gcc|dotnet)w?[-.]?[0-9][0-9.]*$') { return $true }\n    return $false\n}\n\nfunction Get-UncataloguedWin {\n    $dirs = @(\n        (Join-Path $env:USERPROFILE '.cargo\\bin')\n        (Join-Path $env:USERPROFILE '.dotnet\\tools')\n        (Join-Path $env:USERPROFILE '.local\\bin')\n        (Join-Path $env:APPDATA 'npm')\n        (Join-Path $env:USERPROFILE 'scoop\\shims')\n    )\n    if (Get-Command go -CommandType Application,ExternalScript -ErrorAction SilentlyContinue) {\n        try {\n            $gb = if ($env:GOBIN) { $env:GOBIN } else { Join-Path ((& go env GOPATH 2>$null).Trim()) 'bin' }\n            if ($gb) { $dirs += $gb }\n        } catch { Write-Verbose \"go env GOPATH failed; leaving the Go bin dir out of the scan.\" }\n    }\n    $seen = @{}; $out = @()\n    foreach ($d in ($dirs | Where-Object { $_ -and (Test-Path $_) } | Select-Object -Unique)) {\n        Get-ChildItem $d -File -ErrorAction SilentlyContinue |\n            Where-Object { $_.Extension -in '.exe','.cmd','.bat','.ps1' } |\n            ForEach-Object {\n                $base = [IO.Path]::GetFileNameWithoutExtension($_.Name)\n                $bl   = $base.ToLower()\n                if ($base -and -not (Test-KnownTool $base) -and -not $seen.ContainsKey($bl)) {\n                    $seen[$bl] = $true\n                    $out += @{ Name = $base; Path = $_.FullName }\n                }\n            }\n    }\n    return $out\n}\n\nfunction Format-Unknown-Md($items) {\n    $items = @($items)\n    $sb = New-Object System.Text.StringBuilder\n    [void]$sb.AppendLine('### Uncatalogued on PATH')\n    [void]$sb.AppendLine('')\n    [void]$sb.AppendLine('_Dev-manager binaries not in the catalog. Add a `$catalog` row (+ `$refLinks`) to track one._')\n    [void]$sb.AppendLine('')\n    [void]$sb.AppendLine('| Tool | Path |')\n    [void]$sb.AppendLine('|------|------|')\n    $cap = 60; $i = 0\n    foreach ($u in ($items | Sort-Object { $_.Name })) {\n        if ($i -ge $cap) { break }\n        [void]$sb.AppendLine(\"| $($u.Name) | ``$($u.Path)`` |\")\n        $i++\n    }\n    if ($items.Count -gt $cap) { [void]$sb.AppendLine(\"`n_+ $($items.Count - $cap) more._\") }\n    return $sb.ToString()\n}\n\n# ---------------------------------------------------------------------------\n# Host-agnostic bash probe (issue #714, TC-2). The probe script makes no\n# assumption about how it gets run -- WSL today (`wsl.exe -d <distro> -- bash\n# <file>`), SSH next (TC-3) -- so \"build the script\", \"run it via some\n# transport\" and \"parse its output\" are three separable functions, each\n# testable without wsl.exe or a registered distro.\n# ---------------------------------------------------------------------------\n\nfunction New-ToolchainProbeScript {\n    <#\n    Builds the probe script TEXT (LF line endings) with the tool catalog embedded as a\n    quoted heredoc, so the whole probe is one self-contained file any transport can run --\n    a temp file for WSL, stdin for SSH -- instead of reading a second file only the same\n    host can see.\n    #>\n    param([Parameter(Mandatory)][array]$Catalog)\n\n    $tsvLines = $(foreach ($t in $Catalog) { \"{0}`t{1}`t{2}\" -f $t.Name, $t.Exe, ($t.Ver -join ' ') })\n    $tsv = ($tsvLines -join \"`n\")\n\n    $probeSh = @'\n#!/usr/bin/env bash\ninterop=\"${TOOLCHAIN_PROBE_INTEROP_PREFIX:-/mnt/}\"\ndeclare -A known\nwhile IFS=$'\\t' read -r name exe verargs; do\n  [ -z \"$exe\" ] && continue\n  known[\"$(printf '%s' \"$exe\" | tr 'A-Z' 'a-z')\"]=1\n  loc=$(command -v \"$exe\" 2>/dev/null) || continue\n  case \"$loc\" in \"$interop\"*) continue;; esac   # skip Windows tools seen via interop\n  ver=$($exe $verargs 2>&1 | grep -m1 . | tr -d '\\r')\n  printf '%s\\t%s\\t%s\\n' \"$name\" \"$ver\" \"$loc\"\ndone <<'__CATALOG__'\n__TSV__\n__CATALOG__\necho \"===GLOBALS===\"\nrun(){ local e=\"$1\"; local lbl=\"$2\"; shift 2; local p; p=$(command -v \"$e\" 2>/dev/null) || return; case \"$p\" in \"$interop\"*) return;; esac; echo \"### $lbl\"; \"$@\" 2>/dev/null; echo; }\nrun npm   \"npm -g\"        npm ls -g --depth=0\nrun pipx  \"pipx\"          pipx list --short\nrun uv    \"uv tool\"       uv tool list\nrun cargo \"cargo install\" cargo install --list\nrun gem   \"gem (user)\"    gem list --local\nif command -v go >/dev/null 2>&1; then b=\"$(go env GOBIN)\"; [ -z \"$b\" ] && b=\"$(go env GOPATH)/bin\"; if [ -d \"$b\" ]; then echo \"### go install\"; ls -1 \"$b\" 2>/dev/null; echo; fi; fi\necho \"===UNKNOWN===\"\nfor c in rustfmt rustdoc clippy-driver cargo-clippy cargo-fmt cargo-miri rust-gdb rust-gdbgui rust-lldb rust-analyzer rls gofmt godoc npx corepack uvx uvw pydoc 2to3 idle bundler rdoc ri erl epmd escript iex mix rebar3; do known[$c]=1; done\ngb=\"\"; if command -v go >/dev/null 2>&1; then gb=\"$(go env GOBIN 2>/dev/null)\"; [ -z \"$gb\" ] && gb=\"$(go env GOPATH 2>/dev/null)/bin\"; fi\nfor d in \"$HOME/.cargo/bin\" \"$gb\" \"$HOME/.local/bin\" \"$HOME/.dotnet/tools\" /usr/local/bin; do\n  [ -d \"$d\" ] || continue\n  for f in \"$d\"/*; do\n    [ -f \"$f\" ] && [ -x \"$f\" ] || continue\n    b=$(basename \"$f\"); bl=$(printf '%s' \"$b\" | tr 'A-Z' 'a-z')\n    case \"$bl\" in python[0-9]*|pip[0-9]*|ruby[0-9]*|perl[0-9]*|php[0-9]*|node[0-9]*|*.ps1) continue;; esac\n    [ -n \"${known[$bl]}\" ] && continue\n    printf '%s\\t%s\\n' \"$b\" \"$f\"\n  done\ndone | sort -u\n'@\n    $probeSh = ($probeSh -replace \"`r`n\", \"`n\").Replace('__TSV__', $tsv)\n    return $probeSh\n}\n\nfunction Invoke-ToolchainProbe {\n    <#\n    Runs probe script text through a transport and returns the raw stdout as one string.\n    -Transport is a scriptblock: (ScriptText) -> raw output string. Today's only transport\n    is WSL (defined next to its call site, below); TC-3 adds an SSH one with the same shape.\n    #>\n    param(\n        [Parameter(Mandatory)][string]$ScriptText,\n        [Parameter(Mandatory)][scriptblock]$Transport\n    )\n    return & $Transport $ScriptText\n}\n\nfunction ConvertFrom-ToolchainProbeOutput {\n    <#\n    Parses one probe run's raw stdout into catalogued rows, the globals text and the\n    uncatalogued-tool list -- the `===GLOBALS===` / `===UNKNOWN===` sentinel split that\n    used to live inline in the WSL block. Same shapes as before: Rows carry\n    Cat/Name/Version/Path/Source (Source via Get-WslSource); Unknown carries Name/Path.\n    #>\n    param(\n        [Parameter(Mandatory)][AllowEmptyString()][string]$Raw,\n        [Parameter(Mandatory)][array]$Catalog\n    )\n\n    $rows = @()\n    $unknown = @()\n\n    $g = $Raw -split '===GLOBALS==='\n    $toolOut = $g[0]\n    $rest = if ($g.Count -gt 1) { $g[1] } else { '' }\n    $u = $rest -split '===UNKNOWN==='\n    $globalsText = $u[0].Trim()\n    $unknownOut = if ($u.Count -gt 1) { $u[1] } else { '' }\n\n    foreach ($line in ($toolOut -split \"`n\")) {\n        if (-not $line.Trim()) { continue }\n        $parts = $line -split \"`t\"\n        if ($parts.Count -lt 3) { continue }\n        $name = $parts[0].Trim()\n        $ver  = Get-CleanVersion $parts[1]\n        $loc  = $parts[2].Trim()\n        $catEntry = $Catalog | Where-Object { $_.Name -eq $name } | Select-Object -First 1\n        if (-not $catEntry) { continue }\n        $rows += @{ Cat = $catEntry.Cat; Name = $name; Version = $ver; Path = $loc; Source = (Get-WslSource $loc) }\n    }\n\n    foreach ($line in ($unknownOut -split \"`n\")) {\n        if (-not $line.Trim()) { continue }\n        $p = $line -split \"`t\"\n        if ($p.Count -lt 2) { continue }\n        $unknown += @{ Name = $p[0].Trim(); Path = $p[1].Trim() }\n    }\n\n    return @{ Rows = @($rows); GlobalsText = $globalsText; Unknown = @($unknown) }\n}\n\n# Change detection: ignore only the volatile _Generated: line, so a no-change run does not\n# rewrite a report or create an empty commit. Top-level (not inside the dot-source guard)\n# because Publish-ToolchainReport below -- called both for real and by the pwsh-driven\n# tests, which dot-source this script -- reads it.\nfunction Remove-GeneratedLine([string]$text) {\n    ($text -split \"`n\" | Where-Object { $_ -notmatch '^_Generated:' }) -join \"`n\"\n}\n\n# ---------------------------------------------------------------------------\n# SSH toolchain probing (issue #715, TC-3). Reuses the host-agnostic probe above (the\n# script text and the parser are already transport-agnostic) and adds the report-building\n# and publish steps as their own functions, so the local Windows+WSL report and each\n# remote host's report share one implementation instead of two copy-pasted blocks.\n# ---------------------------------------------------------------------------\n\nfunction ConvertTo-ToolchainSshTargets {\n    <#\n    `alias=user@host;alias2=user@host2` -> an array of (alias, target) pairs -- each\n    pair itself a 2-element array, so `$alias, $target = $pair` destructures it.\n\n    A malformed fragment is SKIPPED with a loud warning, not thrown -- config.py's own\n    validation (a target must not contain ';') is the real guard against this ever\n    reaching here from a registered task, but a hand run can pass -SshTargets directly,\n    bypassing that validation entirely. Throwing here would take the #715 failure-isolation\n    guarantee and undo it at the one entry point upstream of the whole per-target loop:\n    one bad fragment would abort every OTHER configured host's probe before it even\n    started, which is precisely the \"one bad target kills the fleet\" failure this script\n    exists to prevent for an unreachable HOST -- a malformed fragment deserves the same\n    isolation, not a worse outcome.\n    #>\n    param([string]$Raw)\n\n    $result = @()\n    if (-not $Raw) { return , $result }\n    foreach ($item in ($Raw -split ';')) {\n        $item = $item.Trim()\n        if (-not $item) { continue }\n        $parts = $item -split '=', 2\n        if ($parts.Count -ne 2 -or -not $parts[0].Trim() -or -not $parts[1].Trim()) {\n            Write-Host \"! malformed -SshTargets entry skipped: '$item' (expected alias=user@host)\" -ForegroundColor Yellow\n            continue\n        }\n        $result += , @($parts[0].Trim(), $parts[1].Trim())\n    }\n    return , $result\n}\n\nfunction Format-GlobalsSection {\n    <#\n    Renders zero or more `{Label; Text}` blocks under one \"### Global packages\" heading --\n    Windows has several labelled blocks (npm -g, pipx, ...); a remote/WSL side has one\n    unlabelled block whose text already carries its own \"### <label>\" sub-headers (the\n    probe script's own `run()` output). Empty/blank-text blocks are dropped, and the\n    heading itself is omitted when nothing is left -- so a host with no global packages\n    installed renders no section at all, exactly as before this was extracted.\n    #>\n    param([array]$Blocks)\n\n    $blocks = @($Blocks | Where-Object { $_ -and $_.Text })\n    if (-not $blocks.Count) { return '' }\n    $sb = New-Object System.Text.StringBuilder\n    [void]$sb.AppendLine('### Global packages')\n    [void]$sb.AppendLine('')\n    foreach ($b in $blocks) {\n        if ($b.Label) {\n            [void]$sb.AppendLine(\"**$($b.Label)**\")\n            [void]$sb.AppendLine('')\n        }\n        [void]$sb.AppendLine('```')\n        [void]$sb.AppendLine($b.Text)\n        [void]$sb.AppendLine('```')\n        [void]$sb.AppendLine('')\n    }\n    return $sb.ToString()\n}\n\nfunction ConvertTo-ToolchainSidecarTools($rows) {\n    <#\n    Rows (Cat/Name/Version/Path/Source) -> the sidecar's `tools` array, in the SAME order\n    Format-SideSection/Format-Table-Md render them (walk $catOrder, then Sort-Object Name\n    within each category) -- so the .json and the .md agree on tool order. `version` gets\n    the same '(present)' fallback Format-Table-Md uses for a blank Version, so the field is\n    never empty (a validate() requirement, #716); `source` is '' rather than omitted when\n    unknown, since every tool has the key.\n    #>\n    $out = @()\n    foreach ($cat in $catOrder) {\n        $catRows = @($rows | Where-Object { $_.Cat -eq $cat } | Sort-Object Name)\n        foreach ($r in $catRows) {\n            $ver = if ($r.Version) { $r.Version } else { '(present)' }\n            $out += [ordered]@{\n                name     = $r.Name\n                category = $r.Cat\n                version  = $ver\n                path     = $r.Path\n                source   = $(if ($r.Source) { $r.Source } else { '' })\n            }\n        }\n    }\n    return , @($out)\n}\n\nfunction ConvertTo-ToolchainSidecarUnknown($items) {\n    <#\n    Unknown (Name/Path) -> the sidecar's `uncatalogued` array, sorted by Name. Unlike\n    Format-Unknown-Md this carries every entry -- no display cap -- since the JSON is a\n    data contract, not a rendered table.\n    #>\n    $out = @()\n    foreach ($u in ($items | Sort-Object { $_.Name })) {\n        $out += [ordered]@{ name = $u.Name; path = $u.Path }\n    }\n    return , @($out)\n}\n\nfunction New-ToolchainReport {\n    <#\n    Assembles ONE report's full Markdown text AND its JSON sidecar (#716, TC-4) from the\n    same -Sides data: title, `_Generated:` line, an optional summary line and an optional\n    `> History:` line, then one `## <Title>` section per entry in -Sides (tool table,\n    global packages, uncatalogued-on-PATH) via Format-SideSection / Format-GlobalsSection\n    / Format-Unknown-Md for the Markdown half, and ConvertTo-ToolchainSidecarTools /\n    ConvertTo-ToolchainSidecarUnknown for the sidecar half -- both read the same\n    -Sides.Rows / -Sides.Unknown, so the two documents can't drift apart from the same\n    call. Each -Sides entry now also carries a `Side` key ('windows' | 'wsl:<distro>' |\n    'linux'), the sidecar's per-side identity -- distinct from `Title`, the Markdown\n    heading text.\n\n    Used for the LOCAL report today (Windows + WSL, two Sides entries, the summary and\n    history lines populated) and for a remote host's report (#715: one Sides entry with\n    Title 'Linux', no summary line, no history line) -- the difference between the two is\n    entirely in what the CALLER passes, not a second code path.\n\n    Returns @{ Markdown = <string>; Sidecar = <ordered hashtable> }. -HostId is the\n    report-file suffix (the store's identity for the box, e.g. 'nitro' or the sanitised\n    local $machine) -- the sidecar's `host`; -Hostname is the box as it reports itself\n    (`hostname`); -Os is 'windows' or 'linux'; -GeneratedIso is the run's UTC timestamp,\n    second precision, e.g. '2026-09-15T14:02:11Z' (the sidecar's `generated` -- distinct\n    from -Now, the local-time display string the Markdown's `_Generated:` line uses).\n    #>\n    param(\n        [Parameter(Mandatory)][string]$HostLabel,\n        [Parameter(Mandatory)][string]$GeneratedOn,\n        [Parameter(Mandatory)][string]$Now,\n        [string]$SummaryLine = '',\n        [string]$HistoryRel = '',\n        [Parameter(Mandatory)][array]$Sides,\n        [Parameter(Mandatory)][string]$HostId,\n        [Parameter(Mandatory)][string]$Hostname,\n        [Parameter(Mandatory)][ValidateSet('windows', 'linux')][string]$Os,\n        [Parameter(Mandatory)][string]$GeneratedIso\n    )\n\n    $md = New-Object System.Text.StringBuilder\n    [void]$md.AppendLine(\"# Toolchain Inventory: $HostLabel\")\n    [void]$md.AppendLine('')\n    [void]$md.AppendLine(\"_Generated: $Now on ${GeneratedOn}_\")\n    [void]$md.AppendLine('')\n    if ($SummaryLine) {\n        [void]$md.AppendLine($SummaryLine)\n        [void]$md.AppendLine('')\n    }\n    if ($HistoryRel) {\n        [void]$md.AppendLine(\"> History: ``git log -- $HistoryRel`` in the claude-memory-sync repo.\")\n        [void]$md.AppendLine('')\n    }\n    $sidecarSides = @()\n    foreach ($side in $Sides) {\n        [void]$md.AppendLine(\"## $($side.Title)\")\n        [void]$md.AppendLine('')\n        [void]$md.Append((Format-SideSection $side.Rows))\n        [void]$md.Append((Format-GlobalsSection $side.GlobalsBlocks))\n        if (@($side.Unknown).Count -gt 0) {\n            [void]$md.Append((Format-Unknown-Md $side.Unknown))\n            [void]$md.AppendLine('')\n        }\n        $sidecarSides += [ordered]@{\n            side         = $side.Side\n            tools        = (ConvertTo-ToolchainSidecarTools $side.Rows)\n            uncatalogued = (ConvertTo-ToolchainSidecarUnknown $side.Unknown)\n        }\n    }\n    $sidecar = [ordered]@{\n        schemaVersion = 1\n        host          = $HostId\n        hostname      = $Hostname\n        os            = $Os\n        generated     = $GeneratedIso\n        sides         = @($sidecarSides)\n    }\n    return @{\n        Markdown = ($md.ToString() -replace \"`r`n\", \"`n\")\n        Sidecar  = $sidecar\n    }\n}\n\nfunction Publish-ToolchainReport {\n    <#\n    Change-detect, write-if-changed, and render/land ONE report -- extracted so the local\n    report and each remote host's report (#715) share one implementation instead of the\n    local report carrying its own copy-pasted change-detection + render tail.\n\n    Ignores only the volatile `_Generated:` line when comparing (Remove-GeneratedLine), so\n    a no-change run does not rewrite the file or create an empty commit. -Label is '' for\n    the local report, so its two status lines stay BYTE-IDENTICAL to before #715 (#714's\n    acceptance greps for one) and '<alias>: ' for a remote. -SkipRenderReason prints its\n    own message instead of rendering -- the local -OutFile testing path, which writes\n    somewhere other than the store and so must not render the store's (different, possibly\n    absent) copy. Returns 'written', 'unchanged' or 'render-failed' (written to disk, but\n    build.py exited non-zero) -- NEVER terminates the script itself, unlike the pre-#715\n    local-only flow this was extracted from. A bare `exit` here would abort the enclosing\n    per-target loop in Invoke-RemoteToolchainInventory via $ErrorActionPreference='Stop'\n    (exit is not a catchable exception, so the surrounding try/catch would not save the\n    remaining targets), defeating the whole point of #715's failure isolation for every\n    target queued after the one whose render failed -- and, for the LOCAL report, would\n    skip SSH probing entirely on a render failure that has nothing to do with SSH\n    reachability. Callers decide what 'render-failed' means for the run as a whole: the\n    main flow folds it into the final exit code (matching the pre-#715 behaviour of exiting\n    1 on a local render failure) but only AFTER SSH probing has run; Invoke-RemoteToolchainInventory\n    folds it into Failed like an unreachable host, so the affected alias is visible and the\n    loop still completes every other target.\n\n    -Sidecar (#716, TC-4) is the JSON sidecar object New-ToolchainReport built alongside\n    -Text, published from the SAME change verdict as the .md -- \"land both or neither\" --\n    EXCEPT that a missing sidecar is also its own trigger: the .md alone changing (or not)\n    decides whether $FileName itself is rewritten (so the sidecar's `generated` timestamp\n    never forces a no-op git diff on the .md), but the sidecar is (re)written whenever it\n    is either due a real change OR simply absent from disk -- covering both this feature's\n    first rollout (an unchanged .md that never had a sidecar) and recovery after build.py\n    rejects one as invalid and deletes it (build.py's own comment). Serialised with\n    `ConvertTo-Json -Depth 6`, LF-normalised, no BOM, keys in the order\n    toolchain_sidecar.py documents (that module is this contract's other half -- the\n    console side that validates it). Not atomic across the two files (round-2 review,\n    #716): a process kill between the .md write and the sidecar write below could leave a\n    stale-but-valid sidecar the \"missing\" check can't detect, since it checks presence,\n    not content. Consistent with every other write in this script (none are transactional\n    either) -- accepted rather than solved here.\n    #>\n    param(\n        [Parameter(Mandatory)][string]$FileName,\n        [Parameter(Mandatory)][string]$Text,\n        [Parameter(Mandatory)][object]$Sidecar,\n        [string]$Rel = '',\n        [string]$Label = '',\n        [switch]$NoRender,\n        [string]$SkipRenderReason = ''\n    )\n\n    $sidecarFileName = [IO.Path]::ChangeExtension($FileName, '.json')\n\n    $mdChanged = $true\n    if (Test-Path $FileName) {\n        $old = ([IO.File]::ReadAllText($FileName)) -replace \"`r\", ''\n        if ((Remove-GeneratedLine $old) -eq (Remove-GeneratedLine $Text)) { $mdChanged = $false }\n    }\n    # A missing sidecar is ALSO a publish trigger, independent of the .md's own diff --\n    # otherwise a host whose report text happens not to change this run (the common case\n    # most weeks) can never get its FIRST sidecar after this feature ships, or recover one\n    # build.py rejected as invalid and (per build.py's own comment) deleted: the .md text\n    # is identical either way, so a check keyed on the .md alone reports 'unchanged'\n    # forever and the sidecar never lands (#716 review). This still writes ONLY the\n    # sidecar when the .md itself is unchanged -- never touching $FileName -- so a\n    # backfill run does not bump `_Generated:` or create a no-op git diff on the .md.\n    $sidecarMissing = -not (Test-Path $sidecarFileName)\n    if (-not $mdChanged -and -not $sidecarMissing) {\n        Write-Host \"= ${Label}No toolchain changes since last run; nothing to publish.\" -ForegroundColor DarkGray\n        return 'unchanged'\n    }\n\n    if ($mdChanged) {\n        [IO.File]::WriteAllText($FileName, $Text, (New-Object System.Text.UTF8Encoding($false)))\n        Write-Host \"= ${Label}Report written: $FileName\" -ForegroundColor Green\n    } else {\n        # Deliberately doesn't say \"unchanged\": this branch still returns 'written' below\n        # and callers (Invoke-RemoteToolchainInventory's $written bucket, the end-of-run\n        # summary) report it as such -- a message containing \"unchanged\" here would read\n        # as contradicting that summary line to anyone scanning a scheduled-task log.\n        Write-Host \"= ${Label}Report text unchanged; sidecar (re)written.\" -ForegroundColor DarkGray\n    }\n    $sidecarJson = (($Sidecar | ConvertTo-Json -Depth 6) -replace \"`r`n\", \"`n\") + \"`n\"\n    [IO.File]::WriteAllText($sidecarFileName, $sidecarJson, (New-Object System.Text.UTF8Encoding($false)))\n\n    if ($NoRender) {\n        Write-Host \"= -NoRender: skipped console render/land.\" -ForegroundColor DarkGray\n    } elseif ($SkipRenderReason) {\n        Write-Host $SkipRenderReason -ForegroundColor DarkGray\n    } elseif (-not $storeAvailable -or -not (Test-Path (Join-Path $ArtifactConsoleDir 'build.py'))) {\n        $missing = @()\n        if (-not $storeAvailable) { $missing += \"store not found: '$ArtifactSourcesDir'\" }\n        if (-not (Test-Path (Join-Path $ArtifactConsoleDir 'build.py'))) {\n            $missing += \"build.py not found under '$ArtifactConsoleDir'\"\n        }\n        Write-Host \"! $($missing -join '; '); wrote the report but skipped render.\" -ForegroundColor Yellow\n    } else {\n        $buildArgs = @('build.py', '--report', $Rel)\n        if ($NoSync) { $buildArgs += '--no-sync' }\n        Push-Location $ArtifactConsoleDir\n        # Piped through Write-Host, not left as a bare native call (issue #715 follow-up):\n        # Publish-ToolchainReport's own return value is CAPTURED by every caller\n        # ($localResult = ...; $result = ... in Invoke-RemoteToolchainInventory), and a\n        # captured function's un-redirected native-command output is swallowed into that\n        # same captured collection instead of reaching the console/log -- verified directly\n        # (`$x = function { & cmd /c echo hi }` yields $x = @('hi ', <return value>), and\n        # nothing is printed) -- which is why build.py's own \"rendered / committed /\n        # pushed\" lines stopped reaching the job log the moment this call moved from\n        # top-level script code into a function whose result every caller assigns.\n        # Write-Host bypasses the success-output stream entirely, so it is never captured\n        # regardless of how the caller uses this function's return value.\n        try { & $pyExe @buildArgs 2>&1 | ForEach-Object { Write-Host $_ } } finally { Pop-Location }\n        # A native command's non-zero exit does NOT throw, even under $ErrorActionPreference =\n        # 'Stop': $PSNativeCommandUseErrorActionPreference is off by default (verified $false on\n        # pwsh 7.6.5). Without this check the line below announces a render that did not happen\n        # and the script still exits 0 -- the same silent-success shape as the bug that buried\n        # this whole branch pre-#320. Exit non-zero so the task's LastTaskResult shows it.\n        if ($LASTEXITCODE -ne 0) {\n            Write-Host \"! build.py exited $LASTEXITCODE; the report is written but NOT rendered: $Rel\" -ForegroundColor Red\n            return 'render-failed'\n        }\n        Write-Host \"= Rendered to artifact-console$(if($NoSync){' (no sync)'}else{' + landed to memory repo'}): $Rel\" -ForegroundColor Green\n    }\n    return 'written'\n}\n\nfunction Resolve-ToolchainSshExe {\n    <#\n    ssh.exe resolved explicitly: the scheduled task's PATH is not the interactive one.\n    Prefers the built-in OpenSSH client (present on every Windows 10/11 box since the\n    optional feature shipped in-box) over whatever `ssh` a `Get-Command` search turns up,\n    for the same reason Register-InventoryTask.ps1 resolves pwsh explicitly rather than\n    trusting PATH.\n    #>\n    $sshExe = Join-Path $env:SystemRoot 'System32\\OpenSSH\\ssh.exe'\n    if (Test-Path -LiteralPath $sshExe) { return $sshExe }\n    $cmd = Get-Command ssh -ErrorAction SilentlyContinue\n    if ($cmd) { return $cmd.Source }\n    return $null\n}\n\nfunction Invoke-ToolchainSshTransport {\n    <#\n    Runs one SSH command, feeding -ScriptText to its stdin as EXACT bytes -- UTF-8, no BOM,\n    no CR -- via a raw System.Diagnostics.Process rather than PowerShell's `|` pipeline\n    operator into a native command.\n\n    THE BUG THIS EXISTS TO FIX (issue #715 follow-up, caught by the real Melody run against\n    real nitro/nucbox -- both `ssh exited 127: bash: line 1: $'hostname\\r': command not\n    found`). The original transport was `$ScriptText | & $sshExe ...`: piping a string to a\n    native command through PowerShell's own pipeline (or calling `.WriteLine()` on its\n    StandardInput directly) terminates it with `Environment.NewLine` (`\\r\\n` on Windows)\n    regardless of the string's own line endings -- verified directly (`od -An -c` on the\n    raw bytes a real local process received). A trailing CRLF on its own does not reliably\n    reproduce a FAILURE against a real local bash (a real local `bash -s` runs `hostname\\r\\n`\n    fine); the exact failure mode over a real ssh channel could not be reproduced from this\n    sandbox (no live target, and the orchestrator's post-merge run is the one place that\n    can exercise real ssh). What IS provably true, and is what this function and its own\n    tests are built around, is that writing exact, caller-specified bytes -- no CR/CRLF\n    PowerShell's own string-to-native-pipe handling would otherwise add -- is unambiguously\n    correct regardless of the precise mechanism behind the original failure, and a raw\n    `System.Diagnostics.Process` with a direct byte-stream write is the one way to guarantee\n    it. No fake `-Transport` scriptblock test can see ANY of this: it is specific to real\n    native-process stdin behaviour, which is why this is now its own function, driven\n    directly by a REAL local bash standing in for ssh (see test_toolchain_ssh_transport.py)\n    rather than only ever exercised through a fake transport. The remote-side band-aid\n    (`tr -d '\\r'`) was rejected: the SENDER has to be correct, not the receiver made\n    tolerant of a bug whose exact trigger isn't even fully pinned down.\n\n    -Arguments is the full, exact argv `$SshExe` runs with (`-o BatchMode=yes ...\n    <target> bash -s` in production) -- passed in whole by the caller, not built here, so\n    a test can point -SshExe at a real bash and -Arguments at just `@('-s')`, skipping the\n    ssh-specific flags/target entirely, and still drive the SAME stdin-writing code this\n    function uses for real. Throws (naming the exit code and any stderr) on a non-zero\n    exit, matching the original transport's contract.\n    #>\n    param(\n        [Parameter(Mandatory)][string]$SshExe,\n        [Parameter(Mandatory)][string[]]$Arguments,\n        [Parameter(Mandatory)][AllowEmptyString()][string]$ScriptText\n    )\n    if (-not $SshExe) { throw 'ssh.exe not found' }\n\n    $psi = New-Object System.Diagnostics.ProcessStartInfo\n    $psi.FileName = $SshExe\n    foreach ($a in $Arguments) { [void]$psi.ArgumentList.Add($a) }\n    $psi.RedirectStandardInput  = $true\n    $psi.RedirectStandardOutput = $true\n    $psi.RedirectStandardError  = $true\n    # Explicit UTF-8 on the READ side too, not just the write: with neither set, .NET\n    # falls back to the console's own output encoding (on this box, code page 437) for\n    # decoding the child's stdout/stderr, silently mangling any non-ASCII byte a remote\n    # tool's version string or path can carry -- verified directly (round-tripping\n    # 'cafe unicode' through an unset-encoding child comes back corrupted). \"Byte-exact\"\n    # cuts both ways: the fix is for the WRITE side's bug, but the read side gets the same\n    # standard while this function is already being rewritten.\n    $utf8NoBom = New-Object System.Text.UTF8Encoding($false)\n    $psi.StandardOutputEncoding = $utf8NoBom\n    $psi.StandardErrorEncoding  = $utf8NoBom\n    $psi.UseShellExecute = $false\n    $psi.CreateNoWindow  = $true\n\n    $proc = [System.Diagnostics.Process]::Start($psi)\n    try {\n        # Reads started BEFORE writing stdin, and run async throughout: the child can start\n        # producing output before we finish writing input, and on a large enough probe\n        # script writing everything first (with nothing draining stdout/stderr) risks the\n        # classic same-process pipe deadlock -- the child blocks on a full stdout/stderr\n        # pipe while we block trying to finish writing a full stdin pipe.\n        $stdoutTask = $proc.StandardOutput.ReadToEndAsync()\n        $stderrTask = $proc.StandardError.ReadToEndAsync()\n        try {\n            # LF only, defensively: New-ToolchainProbeScript already emits LF-only text\n            # (its own `-replace \"`r`n\", \"`n\"`), but this is the one place a CR could\n            # still slip through -- a one-line literal like 'hostname' has no line ending\n            # of its own to normalise, and a future caller might pass one that does.\n            $normalized = $ScriptText -replace \"`r`n\", \"`n\" -replace \"`r\", \"`n\"\n            $bytes = [System.Text.Encoding]::UTF8.GetBytes($normalized)\n            $proc.StandardInput.BaseStream.Write($bytes, 0, $bytes.Length)\n            $proc.StandardInput.BaseStream.Flush()\n        } catch {\n            # A process that exits (or closes its own stdin) before or while we're still\n            # writing -- e.g. a real ssh auth failure (\"Permission denied (publickey)\"),\n            # which never even spawns bash -- throws here (\"the pipe is being closed\")\n            # BEFORE the real, useful failure reason below is ever reached. Swallowing it\n            # is deliberate: the process's own exit code + stderr, read next, is the\n            # actual cause, and a caller told \"the pipe is being closed\" instead of\n            # \"Permission denied\" or \"Connection refused\" has lost the one thing this\n            # whole function exists to report accurately.\n            Write-Verbose \"stdin write failed (process likely already exited): $($_.Exception.Message)\"\n        } finally {\n            try { $proc.StandardInput.Close() } catch { Write-Verbose \"stdin already closed.\" }\n        }\n        $proc.WaitForExit()\n        $stdout = $stdoutTask.GetAwaiter().GetResult()\n        $stderr = $stderrTask.GetAwaiter().GetResult()\n\n        if ($proc.ExitCode -ne 0) {\n            throw \"ssh exited $($proc.ExitCode)$(if ($stderr.Trim()) { \": $($stderr.Trim())\" })\"\n        }\n        return $stdout\n    } finally {\n        $proc.Dispose()\n    }\n}\n\nfunction Invoke-RemoteToolchainInventory {\n    <#\n    Probes every configured SSH target, publishing one toolchain-inventory-<alias>.md per\n    reachable host and leaving an unreachable host's previous report untouched (#715).\n\n    -Transport is `param($target, $scriptText)` -> raw stdout as one string, and throws (or\n    the caller treats a null/empty hostname response as unreachable too) when the host\n    can't be reached; the production transport pipes the script over\n    `ssh -o BatchMode=yes -o ConnectTimeout=8 <target> bash -s` (script on stdin, no remote\n    temp file), with ssh.exe resolved explicitly since the scheduled task's PATH is not the\n    interactive one. -Now is the SAME 'yyyy-MM-dd HH:mm' string the local report's\n    _Generated: line uses, so every report from one run agrees. -LocalHost names where the\n    SSH hop originates, for the remote _Generated: line's \"via ssh from <local>\".\n\n    Per target, in order: the hostname (the transport given the one-line script\n    `hostname`, so the title/`_Generated:` line carries the real name, not the alias) --\n    then the host-agnostic probe script through the same transport, parsed, built into a\n    single-`linux`-side report, and published under `-Label '<alias>: '`. A failure at any\n    step for one target is caught, printed as `! <alias>: unreachable (<reason>)`, and does\n    NOT stop the loop -- the local report and every other target still publish.\n    #>\n    param(\n        [Parameter(Mandatory)][array]$Targets,\n        [Parameter(Mandatory)][scriptblock]$Transport,\n        [Parameter(Mandatory)][string]$Now,\n        [Parameter(Mandatory)][string]$NowIso,\n        [Parameter(Mandatory)][string]$LocalHost,\n        [switch]$NoRender\n    )\n\n    $written = @()\n    $unchanged = @()\n    $failed = @()\n\n    foreach ($pair in $Targets) {\n        $alias, $target = $pair\n        try {\n            $remoteHostName = ((& $Transport $target 'hostname') | Out-String).Trim()\n            if (-not $remoteHostName) { throw 'empty hostname response' }\n\n            $probeScript = New-ToolchainProbeScript -Catalog $catalog\n            $raw = (& $Transport $target $probeScript) | Out-String\n            $parsed = ConvertFrom-ToolchainProbeOutput -Raw $raw -Catalog $catalog\n\n            $side = @{\n                Title         = 'Linux'\n                Side          = 'linux'\n                Rows          = $parsed.Rows\n                GlobalsBlocks = @(@{ Label = $null; Text = $parsed.GlobalsText })\n                Unknown       = $parsed.Unknown\n            }\n            $report = New-ToolchainReport -HostLabel \"$remoteHostName ($alias)\" `\n                -GeneratedOn \"$remoteHostName via ssh from $LocalHost\" -Now $Now -Sides @($side) `\n                -HostId $alias -Hostname $remoteHostName -Os 'linux' -GeneratedIso $NowIso\n\n            $remoteFileName = \"toolchain-inventory-$alias.md\"\n            $remoteOutPath = if ($storeAvailable) { Join-Path $storeDir $remoteFileName } else { Join-Path $stateDir $remoteFileName }\n            $remoteRel = \"$ArtifactCategory/$remoteFileName\"\n\n            $result = Publish-ToolchainReport -FileName $remoteOutPath -Text $report.Markdown `\n                -Sidecar $report.Sidecar -Rel $remoteRel -Label \"${alias}: \" -NoRender:$NoRender\n            # 'render-failed' (build.py exited non-zero) is isolated exactly like an\n            # unreachable host: the report DID reach the store, but is not counted as a\n            # clean success, and this alias must not stop the loop for the others.\n            if ($result -eq 'written') { $written += $alias }\n            elseif ($result -eq 'unchanged') { $unchanged += $alias }\n            else { $failed += $alias }\n        } catch {\n            Write-Host \"! ${alias}: unreachable ($($_.Exception.Message))\" -ForegroundColor Yellow\n            $failed += $alias\n        }\n    }\n\n    return @{\n        Written   = $written\n        Unchanged = $unchanged\n        Failed    = $failed\n        ExitCode  = $(if ($failed.Count -gt 0) { 2 } else { 0 })\n    }\n}\n\n# Run the probing/report/render flow only when executed (pwsh -File / & script.ps1),\n# not when dot-sourced for testing (. ./Get-ToolchainInventory.ps1), which only wants\n# the functions and the catalog above defined.\nif ($MyInvocation.InvocationName -ne '.') {\n\n    Write-Host \"= Toolchain inventory: probing Windows side...\" -ForegroundColor Cyan\n\n    # ---------------------------------------------------------------------------\n    # Windows probing\n    # ---------------------------------------------------------------------------\n    $winRows = @()\n    foreach ($tool in $catalog) {\n        $r = Get-WinToolInfo $tool\n        if ($r) { $winRows += $r; Write-Host (\"  + {0,-16} {1}\" -f $r.Name, $r.Version) }\n    }\n\n    # Windows global packages\n    $winGlobals = [ordered]@{}\n    function Add-WinGlobal($label, $exe, $cmdArgs) {\n        if (Get-Command $exe -CommandType Application,ExternalScript -ErrorAction SilentlyContinue) {\n            try {\n                # stdout only -- keep error spew (e.g. a missing npm global prefix) out of the report\n                $o = (& $exe @cmdArgs 2>$null | Out-String).Trim()\n                if ($o) { $script:winGlobals[$label] = $o }\n            } catch { Write-Verbose \"$label ($exe) failed; leaving it out of the report.\" }\n        }\n    }\n    Add-WinGlobal 'npm -g'             'npm'   @('ls','-g','--depth=0')\n    Add-WinGlobal 'pipx'               'pipx'  @('list','--short')\n    Add-WinGlobal 'uv tool'            'uv'    @('tool','list')\n    Add-WinGlobal 'cargo install'      'cargo' @('install','--list')\n    Add-WinGlobal 'gem (user)'         'gem'   @('list','--local')\n    if (Get-Command go -CommandType Application,ExternalScript -ErrorAction SilentlyContinue) {\n        try {\n            $gp = (& go env GOPATH 2>$null).Trim()\n            $gobin = if ($env:GOBIN) { $env:GOBIN } else { Join-Path $gp 'bin' }\n            if (Test-Path $gobin) {\n                $bins = Get-ChildItem $gobin -File -ErrorAction SilentlyContinue |\n                        Select-Object -ExpandProperty Name\n                if ($bins) { $winGlobals['go install'] = ($bins -join \"`n\") }\n            }\n        } catch { Write-Verbose \"go env GOPATH failed; leaving the 'go install' list out of the report.\" }\n    }\n\n    # Uncatalogued dev tools sitting on PATH (heads-up section). @() forces array\n    # semantics so a single hit isn't unwrapped to a bare hashtable (whose .Count\n    # would be its key count, not 1).\n    $winUnknown = @(Get-UncataloguedWin)\n    if ($winUnknown.Count) { Write-Host (\"  ~ {0} uncatalogued on PATH\" -f $winUnknown.Count) -ForegroundColor DarkYellow }\n\n    # ---------------------------------------------------------------------------\n    # WSL probing. The probe logic is written to a real .sh file on disk and run\n    # via `bash <file>` -- NOT passed as a `bash -lc <string>` argument, because\n    # wsl.exe strips backslash escapes (\\t \\n \\r) from command-line arguments,\n    # which silently breaks IFS/printf/tr. A script on disk is immune to that.\n    # ---------------------------------------------------------------------------\n    function ConvertTo-WslPath([string]$winPath) {\n        $p = (& wsl.exe -d $WslDistro wslpath -a ($winPath -replace '\\\\','/') 2>$null)\n        $p = if ($p) { \"$p\".Trim() } else { '' }\n        if (-not $p) {\n            $drive = $winPath.Substring(0,1).ToLower()\n            $p = \"/mnt/$drive\" + ($winPath.Substring(2) -replace '\\\\','/')\n        }\n        return $p\n    }\n\n    $wslRows = @()\n    $wslGlobalsText = ''\n    $wslUnknown = @()\n    $wslAvailable = $false\n    if ($WslDistro) {\n        $wslExe = Get-Command wsl.exe -ErrorAction SilentlyContinue\n        if ($wslExe) {\n            # Is the distro registered? (wsl -l -q emits UTF-16 unless WSL_UTF8 set)\n            $env:WSL_UTF8 = '1'\n            $distros = (& wsl.exe -l -q 2>$null) -split \"`n\" | ForEach-Object { $_.Trim() } | Where-Object { $_ }\n            if ($distros -contains $WslDistro) {\n                $wslAvailable = $true\n                Write-Host \"= Probing WSL:$WslDistro side...\" -ForegroundColor Cyan\n                $utf8 = New-Object System.Text.UTF8Encoding($false)\n\n                $probeScript = New-ToolchainProbeScript -Catalog $catalog\n\n                # WSL transport: the script is written to a real file on disk and run via\n                # `bash <path>`, never passed as a `bash -lc <string>` argument -- wsl.exe\n                # strips backslash escapes from arguments, per the header comment above.\n                # TC-3's SSH transport will pipe `bash -s` on stdin instead.\n                $wslTransport = {\n                    param([string]$ScriptText)\n                    $shPath = Join-Path $tmpDir 'probe.sh'\n                    [IO.File]::WriteAllText($shPath, $ScriptText, $utf8)\n                    $wslSh = ConvertTo-WslPath $shPath\n                    $raw = (& wsl.exe -d $WslDistro -- bash $wslSh 2>$null | Out-String) -replace \"`r\",''\n                    Remove-Item $shPath -ErrorAction SilentlyContinue\n                    return $raw\n                }\n\n                $raw = Invoke-ToolchainProbe -ScriptText $probeScript -Transport $wslTransport\n                $parsed = ConvertFrom-ToolchainProbeOutput -Raw $raw -Catalog $catalog\n                $wslRows = $parsed.Rows\n                $wslGlobalsText = $parsed.GlobalsText\n                $wslUnknown = $parsed.Unknown\n                foreach ($r in $wslRows) { Write-Host (\"  + {0,-16} {1}\" -f $r.Name, $r.Version) }\n                if ($wslUnknown.Count) { Write-Host (\"  ~ {0} uncatalogued on PATH\" -f $wslUnknown.Count) -ForegroundColor DarkYellow }\n            } else {\n                Write-Host \"! WSL distro '$WslDistro' not registered; skipping WSL side.\" -ForegroundColor Yellow\n            }\n        } else {\n            Write-Host \"! wsl.exe not found; skipping WSL side.\" -ForegroundColor Yellow\n        }\n    }\n\n    # ---------------------------------------------------------------------------\n    # Build + publish the LOCAL report (Windows + WSL), via the shared functions above.\n    # ---------------------------------------------------------------------------\n    $now = Get-Date -Format 'yyyy-MM-dd HH:mm'\n    $nowIso = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')\n\n    $winGlobalsBlocks = @($winGlobals.Keys | ForEach-Object { @{ Label = $_; Text = $winGlobals[$_] } })\n    $sides = @(@{ Title = 'Windows'; Side = 'windows'; Rows = $winRows; GlobalsBlocks = $winGlobalsBlocks; Unknown = $winUnknown })\n    # The machine goes in the TITLE, not only the _Generated: line -- a reader who opens the\n    # rendered page should not have to work out whose toolchain they are looking at, which\n    # was a defect even back when only one machine wrote this file (issue #231).\n    $wslCountLabel = if ($wslAvailable) { \"WSL:$WslDistro $($wslRows.Count) tools\" } else { 'WSL not probed' }\n    if ($wslAvailable) {\n        $sides += @{ Title = \"WSL: $WslDistro\"; Side = \"wsl:$WslDistro\"; Rows = $wslRows\n                     GlobalsBlocks = @(@{ Label = $null; Text = $wslGlobalsText }); Unknown = $wslUnknown }\n    }\n    $localReport = New-ToolchainReport -HostLabel $hostName `\n        -GeneratedOn \"$hostName (editors: $(if($includeEd){'included'}else{'excluded'}))\" -Now $now `\n        -SummaryLine \"**Windows:** $($winRows.Count) tools &middot; **$wslCountLabel**\" `\n        -HistoryRel \"$ArtifactCategory/$fileName\" -Sides $sides `\n        -HostId $machine -Hostname $hostName -Os 'windows' -GeneratedIso $nowIso\n    $mdText = $localReport.Markdown\n\n    # Always record the last run time (out-of-repo state, untracked).\n    [IO.File]::WriteAllText((Join-Path $stateDir 'last-run.txt'), \"$now on $hostName`n\",\n                            (New-Object System.Text.UTF8Encoding($false)))\n\n    # -OutFile is the local-test path: the report went where the caller asked, NOT into the\n    # store -- but the store's copy (named by $rel below) is a different file that may be\n    # stale or absent, so rendering here would publish something this run did not write.\n    # `$PSBoundParameters` is a bind-time snapshot, so it still answers \"did the caller pass\n    # it\" after the store branch earlier in the script assigned $OutFile itself. Indexed\n    # rather than .ContainsKey(), so an explicitly EMPTY `-OutFile ''` is falsy here exactly\n    # as it is at the two `-not $OutFile` tests above: that run does write to the store, so\n    # it is the one that SHOULD render.\n    $localSkipReason = if ($PSBoundParameters['OutFile']) {\n        '= -OutFile: wrote the report there; skipped the store render/land.'\n    } else { '' }\n    $localResult = Publish-ToolchainReport -FileName $OutFile -Text $mdText -Sidecar $localReport.Sidecar `\n        -Rel \"$ArtifactCategory/$fileName\" -NoRender:$NoRender -SkipRenderReason $localSkipReason\n\n    # ---------------------------------------------------------------------------\n    # SSH toolchain probing (issue #715, TC-3). Runs regardless of whether the local\n    # report changed -- a stable local box must not hide a drifting SSH host, or vice\n    # versa, which is exactly why the local branch above no longer returns early.\n    # ---------------------------------------------------------------------------\n    $sshTargetPairs = ConvertTo-ToolchainSshTargets $SshTargets\n    # Every fragment malformed (only reachable from a hand-typed -SshTargets -- the\n    # scheduled/registered path always carries config.py-validated values) must not look\n    # identical to \"no SSH targets configured\": that would silently probe nothing and\n    # still exit 0, hiding a typo behind the one Yellow line ConvertTo-ToolchainSshTargets\n    # already printed per skipped fragment. $SshTargets non-empty but $sshTargetPairs\n    # empty is the tell.\n    $sshTargetsAllMalformed = [bool]$SshTargets -and (@($sshTargetPairs).Count -eq 0)\n    if ($sshTargetsAllMalformed) {\n        Write-Host \"! -SshTargets was set but every fragment was malformed; nothing was probed.\" -ForegroundColor Red\n    }\n    $remote = $null\n    if (@($sshTargetPairs).Count -gt 0) {\n        Write-Host \"= Probing $(@($sshTargetPairs).Count) SSH host(s)...\" -ForegroundColor Cyan\n        $sshExe = Resolve-ToolchainSshExe\n        # Thin closure over Invoke-ToolchainSshTransport (issue #715 follow-up): the real\n        # byte-exact stdin write lives there, driven directly by its own tests against a\n        # real local bash; this just supplies the production argv and executable.\n        $sshTransport = {\n            param([string]$Target, [string]$ScriptText)\n            Invoke-ToolchainSshTransport -SshExe $sshExe `\n                -Arguments @('-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8', $Target, 'bash', '-s') `\n                -ScriptText $ScriptText\n        }\n        $remote = Invoke-RemoteToolchainInventory -Targets $sshTargetPairs -Transport $sshTransport `\n            -Now $now -NowIso $nowIso -LocalHost $hostName -NoRender:$NoRender\n        if ($remote.Written.Count -gt 0) {\n            Write-Host (\"= SSH hosts written: {0}\" -f ($remote.Written -join ', ')) -ForegroundColor Green\n        }\n        if ($remote.Unchanged.Count -gt 0) {\n            Write-Host (\"= SSH hosts unchanged: {0}\" -f ($remote.Unchanged -join ', ')) -ForegroundColor DarkGray\n        }\n        if ($remote.Failed.Count -gt 0) {\n            Write-Host (\"! SSH hosts unreachable: {0}\" -f ($remote.Failed -join ', ')) -ForegroundColor Yellow\n        }\n    }\n\n    Write-Host \"= Done.\" -ForegroundColor Cyan\n    # A remote failure (2) outranks a local-only render failure (1, the pre-#715 behaviour\n    # of exiting non-zero when build.py fails) -- both are folded in HERE, after SSH\n    # probing has already run to completion, never as an early `exit` from inside\n    # Publish-ToolchainReport (which would abort probing before it started).\n    $exitCode = 0\n    if ($localResult -eq 'render-failed') { $exitCode = 1 }\n    if ($sshTargetsAllMalformed) { $exitCode = 2 }\n    if ($remote -and $remote.ExitCode -ne 0) { $exitCode = $remote.ExitCode }\n    if ($exitCode -ne 0) { exit $exitCode }\n}\n";
+
+/**
+ * Runs 1.x's own `Get-ToolchainInventory.ps1` through `pwsh` (#52, 52b; 1.x had no Linux
+ * equivalent, `toolchain_sidecar.py`, `sched_spec.py:264-273`), kind `toolchain-inventory`,
+ * capability `agent.scan.toolchain-inventory`. Shipped and run, not rewritten (`data/README.md`):
+ * the script is 1,397 lines whose output is the byte-compare target, so a TypeScript rewrite
+ * would have to re-derive every probe and formatting rule and still match it byte for byte.
+ *
+ * Windows-only, as 1.x was: on any other platform, `run` returns a skipped payload without
+ * spawning anything. The invocation is the script's own local-test path (`-OutFile -NoRender`,
+ * no `-SshTargets`/`-SourcesDir`/`-PythonExe`, no `-WslDistro` override beyond the script's own
+ * default) -- it calls no Python, needs no artifacts store, renders nothing, and writes the
+ * `.md` report plus its `.json` sidecar next to it. The child runs with `cwd` set to the scans
+ * directory, never the agent's own cwd: the catalog probes include `pnpm --version`, and pnpm 12
+ * rewrites `pnpm-lock.yaml` in whatever directory it runs in.
+ */
+const TIMEOUT_MS$1 = 600_000;
+const SCRIPT_FILENAME = "Get-ToolchainInventory.ps1";
+function scansDir$1(stateDir) {
+    return path.join(stateDir, "scans");
+}
+function sha256Hex(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+/** Writes the embedded script to `<state>/scans/Get-ToolchainInventory.ps1` when absent or its
+ *  bytes differ from the bundle's copy (a sha-256 compare, so the state dir always holds the
+ *  bundle's copy), via a temp name in the same directory and a rename -- so a killed agent never
+ *  leaves a half-written script. Leaves an identical file untouched (no write, no rename). */
+function ensureScript(fs, stateDir) {
+    const dir = scansDir$1(stateDir);
+    fs.mkdir(dir);
+    const dest = path.join(dir, SCRIPT_FILENAME);
+    const existing = fs.readFile(dest);
+    if (existing !== null && sha256Hex(existing.toString("utf8")) === sha256Hex(scriptText)) {
+        return dest;
+    }
+    const tmp = path.join(dir, `.${SCRIPT_FILENAME}.${process.pid}-${Date.now()}.tmp`);
+    fs.writeFile(tmp, scriptText);
+    fs.rename(tmp, dest);
+    return dest;
+}
+/** The file-name suffix the script itself uses (`[System.Net.Dns]::GetHostName()`, matched by
+ *  `os.hostname()`) -- not decision 9's configured `machine`/`--name`, so the byte-compare's file
+ *  name always agrees with 1.x's own regardless of an operator override. */
+function sanitizeMachine(hostname) {
+    return hostname.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function lastNonEmptyLine$1(text) {
+    const lines = text
+        .split("\n")
+        .map((line) => line.replace(/\r$/, ""))
+        .filter((line) => line.length > 0);
+    return lines.length > 0 ? lines[lines.length - 1] : "";
+}
+// The script's own three result literals (local run, empty -Label): `startsWith`, never
+// `includes`, so the missing-sidecar backfill line -- which also happens to contain the word
+// "unchanged" -- is never confused with the genuinely-unchanged line above it.
+const WRITTEN_LINE_PREFIXES = ["= Report written:", "= Report text unchanged; sidecar (re)written."];
+const UNCHANGED_LINE_PREFIX = "= No toolchain changes since last run";
+function classifyResult(stdout) {
+    for (const raw of stdout.split("\n")) {
+        const line = raw.replace(/\r$/, "");
+        if (WRITTEN_LINE_PREFIXES.some((prefix) => line.startsWith(prefix)))
+            return "written";
+        if (line.startsWith(UNCHANGED_LINE_PREFIX))
+            return "unchanged";
+    }
+    throw new Error("Get-ToolchainInventory.ps1: no recognized result line in stdout");
+}
+async function runToolchainInventory(deps, signal) {
+    if (deps.platform !== "win32") {
+        return {
+            skipped: true,
+            reason: "toolchain-inventory is Windows-only (1.x had no Linux equivalent)",
+        };
+    }
+    const scriptFile = ensureScript(deps.fs, deps.stateDir);
+    const machine = sanitizeMachine(deps.hostname());
+    const fileName = `toolchain-inventory-${machine}.md`;
+    const dir = scansDir$1(deps.stateDir);
+    const outFile = path.join(dir, fileName);
+    // A `shim` result (a `.cmd`/`.bat` on PATH ahead of the native binary) is impossible for pwsh
+    // in practice but is mapped to the same error as `not-found` -- `found` is false either way.
+    const found = deps.which("pwsh");
+    if (!found.found)
+        throw new Error("pwsh not found on PATH");
+    const result = await deps.run(found.path, ["-NoProfile", "-File", scriptFile, "-OutFile", outFile, "-NoRender"], { cwd: dir, timeoutMs: TIMEOUT_MS$1, signal });
+    // Checked in this order deliberately: when the scan's own request timeout and this signal fire
+    // at the same instant (verbs/scan.ts aborts at the same timeoutMs this run was given), the
+    // internal timer's `timedOut` is what gets reported here -- 49c has already answered its own
+    // 504 to the client by then, so only this background log line ever reads which one won.
+    if (result.timedOut) {
+        throw new Error(`Get-ToolchainInventory.ps1 timed out after ${TIMEOUT_MS$1} ms`);
+    }
+    if (result.aborted) {
+        throw new Error("scan aborted");
+    }
+    if (result.code !== 0) {
+        const detail = lastNonEmptyLine$1(result.stderr) || lastNonEmptyLine$1(result.stdout);
+        throw new Error(`Get-ToolchainInventory.ps1 exited ${result.code}: ${detail}`);
+    }
+    const resultKind = classifyResult(result.stdout);
+    const markdownBuf = deps.fs.readFile(outFile);
+    if (markdownBuf === null) {
+        throw new Error(`Get-ToolchainInventory.ps1: could not read ${outFile}`);
+    }
+    const sidecarPath = outFile.replace(/\.md$/, ".json");
+    const sidecarBuf = deps.fs.readFile(sidecarPath);
+    if (sidecarBuf === null) {
+        throw new Error(`Get-ToolchainInventory.ps1: could not read ${sidecarPath}`);
+    }
+    return {
+        machine,
+        fileName,
+        markdown: markdownBuf.toString("utf8"),
+        sidecar: JSON.parse(sidecarBuf.toString("utf8")),
+        result: resultKind,
+    };
+}
+
+const CONTEXT_PRESSURE_FLOAT_KEYS = new Set(["generatedAt", "peakPct", "lastAt", "mtime"]);
+const SUBAGENT_COST_FLOAT_KEYS = new Set(["generatedAt", "costUsd", "lastAt", "mtime"]);
+const TIMEOUT_MS = 900_000;
+function scansDir(deps) {
+    return path.join(deps.stateDir, "scans");
+}
+function cachePath(deps, kind) {
+    return path.join(scansDir(deps), `${kind}.json`);
+}
+function loadPrevious(deps, kind) {
+    const raw = deps.fs.readFile(cachePath(deps, kind));
+    return parseCache(raw !== null ? raw.toString("utf8") : null);
+}
+/** 1.x refuses to clobber a good cache with an empty one (`main()`'s `if not data["scanned"]`
+ *  branch) -- a `scanned === 0` result is returned to the caller same as any other, just never
+ *  written. */
+function writeIfNonEmpty(deps, kind, result, floatKeys) {
+    if (result.scanned === 0)
+        return;
+    const text = dumps(result, { indent: 2, floatKeys });
+    deps.fs.mkdir(scansDir(deps));
+    deps.fs.writeFile(cachePath(deps, kind), writeCache(text));
+}
+// `ctx.signal` (49c's own abort/timeout bookkeeping) is honoured; `ctx.now` is not -- it is the
+// verb dispatcher's real wall-clock at request-arrival, only used for its own response envelope.
+// `collect`'s `generatedAt` (1.x's `time.time()`) comes from `deps.now` instead, so a test can
+// inject a fixed or non-integral clock without a real request in flight.
+function registerScanKinds(scans, deps) {
+    scans.register("context-pressure", {
+        timeoutMs: TIMEOUT_MS,
+        run: async (ctx) => {
+            const root = deps.projectsRoot();
+            if (!deps.fs.isDir(root))
+                throw new Error(`no session-log root at ${root}`);
+            const previous = loadPrevious(deps, "context-pressure");
+            const result = collect$1(root, previous, ctx.signal, deps.fs, deps.now);
+            writeIfNonEmpty(deps, "context-pressure", result, CONTEXT_PRESSURE_FLOAT_KEYS);
+            return result;
+        },
+    });
+    scans.register("subagent-cost", {
+        timeoutMs: TIMEOUT_MS,
+        run: async (ctx) => {
+            const root = deps.projectsRoot();
+            if (!deps.fs.isDir(root))
+                throw new Error(`no session-log root at ${root}`);
+            const previous = loadPrevious(deps, "subagent-cost");
+            const result = collect(root, previous, ctx.signal, deps.fs, deps.now);
+            writeIfNonEmpty(deps, "subagent-cost", result, SUBAGENT_COST_FLOAT_KEYS);
+            return result;
+        },
+    });
+    // Producer only, never cached (52b, E4 plan §7.8: a cold run is kilobytes of I/O, not the
+    // ~940MB context-pressure reads that motivate a cache). No custom timeoutMs -- the registry's
+    // own default is generous enough for "~8 stats per repo against small text files".
+    scans.register("memory-footprint", {
+        run: async (ctx) => {
+            const { repos } = listRepos(deps.reposRoot(), deps.repoFs);
+            return overviewSummary(deps.fs, repos, deps.homedir(), deps.projectsRoot(), deps.platform, deps.env, ctx.signal);
+        },
+    });
+    scans.register("toolchain-inventory", {
+        timeoutMs: TIMEOUT_MS$1,
+        run: (ctx) => runToolchainInventory({
+            platform: deps.platform,
+            stateDir: deps.stateDir,
+            hostname: deps.hostname,
+            which: deps.which,
+            run: deps.run,
+            fs: deps.fs,
+        }, ctx.signal),
+    });
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  registerScanKinds: registerScanKinds
+});
+
 const ABANDON_MULTIPLIER = 5;
 /** Runs the scan and settles `inFlight`'s bookkeeping for it, independent of whatever the request
  *  handler itself already answered the client with (it may have already returned a `504`). Skips
@@ -74205,4 +75738,324 @@ var scan = /*#__PURE__*/Object.freeze({
   registerScanVerbs: registerScanVerbs
 });
 
+const REG_TIMEOUT_MS = 10_000;
+const HKLM_KEY = String.raw `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment`;
+const HKCU_KEY = String.raw `HKCU\Environment`;
+// reg.exe's own output shape: a blank line, the key line, then the value line indented four
+// spaces with four-space column gaps ("    Path    REG_EXPAND_SZ    <value>"), CRLF, a trailing
+// blank line. The value can itself contain spaces ("C:\Program Files\Git\cmd"), so this is never
+// split on whitespace -- matched as one line and group 2 taken whole.
+const VALUE_LINE = /^\s*\S+\s+(REG_EXPAND_SZ|REG_SZ)\s+(.*)$/m;
+function expandVars(value, env) {
+    const upper = new Map();
+    for (const [name, v] of Object.entries(env)) {
+        if (v !== undefined)
+            upper.set(name.toUpperCase(), v);
+    }
+    return value.replace(/%([^%]+)%/g, (whole, name) => upper.get(name.toUpperCase()) ?? whole);
+}
+/** One `reg.exe query <key> /v Path`. A non-zero exit -- including the documented "missing value"
+ *  case (`ERROR: The system was unable to find the specified registry key or value.` on stderr) --
+ *  is treated as an empty hive, not a throw: `ok: false` lets the caller decide whether BOTH hives
+ *  failing means falling back to the process PATH entirely. */
+async function readHive(regExe, key, deps) {
+    const result = await deps.run(regExe, ["query", key, "/v", "Path"], { timeoutMs: REG_TIMEOUT_MS });
+    if (result.code !== 0)
+        return { ok: false, value: "" };
+    const stripped = result.stdout.replace(/\r/g, "");
+    const match = VALUE_LINE.exec(stripped);
+    const raw = match?.[2] ?? "";
+    return { ok: true, value: expandVars(raw, deps.env) };
+}
+/** `{ path, source }` for the machine this process is actually on (E4 §5 decision 19). Win32: both
+ *  hives, joined machine-then-user with `;` (a missing/failed hive contributes "", which
+ *  `findExecutable` already skips as an empty PATH entry); both hives failing falls back to the
+ *  process's own PATH/Path, exactly like the non-Windows case below. Everywhere else: the process
+ *  PATH, and `reg.exe` is never invoked at all. */
+async function searchPath(deps) {
+    const processFallback = () => ({
+        path: deps.env.PATH ?? deps.env.Path ?? "",
+        source: "process",
+    });
+    if (deps.platform !== "win32")
+        return processFallback();
+    const systemRoot = deps.env.SystemRoot ?? String.raw `C:\Windows`;
+    const regExe = path.win32.join(systemRoot, "System32", "reg.exe");
+    const [machine, user] = await Promise.all([
+        readHive(regExe, HKLM_KEY, deps),
+        readHive(regExe, HKCU_KEY, deps),
+    ]);
+    if (!machine.ok && !user.ok)
+        return processFallback();
+    return { path: [machine.value, user.value].join(";"), source: "registry" };
+}
+// Where a POSIX version manager keeps the binaries it manages (1.x `preflight.py:257-262`): env
+// var override, default `~/<defaultHome>`, then the subpath under that root. `*` in a subpath is
+// globbed and sorted newest-first (nvm keeps every version side by side with no stable "default"
+// symlink to point at).
+const MANAGER_DIRS = [
+    { envVar: "FNM_DIR", defaultHome: ".local/share/fnm", subpath: "aliases/default/bin" },
+    { envVar: "NVM_DIR", defaultHome: ".nvm", subpath: "versions/node/*/bin" },
+    { envVar: "VOLTA_HOME", defaultHome: ".volta", subpath: "bin" },
+    { envVar: "ASDF_DATA_DIR", defaultHome: ".asdf", subpath: "shims" },
+];
+/** Sort key for a version directory name ("v24.18.0"): the digit runs, compared numerically so v9
+ *  sorts below v10 -- a plain string sort puts them the other way round (1.x `_version_key`). */
+function versionKey(name) {
+    const digits = name.match(/\d+/g);
+    return digits ? digits.map((d) => Number.parseInt(d, 10)) : [0];
+}
+function compareVersionsNewestFirst(a, b) {
+    const ka = versionKey(a);
+    const kb = versionKey(b);
+    const len = Math.max(ka.length, kb.length);
+    for (let i = 0; i < len; i++) {
+        const diff = (kb[i] ?? 0) - (ka[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/** Every version-manager bin directory that exists on this machine, newest-version-first within a
+ *  manager (1.x `_manager_bin_dirs`, `preflight.py:272-291`). `[]` on Windows, which has its own
+ *  PATH-refresh route above and no version-manager convention of its own to search. Returns
+ *  DIRECTORIES (not the resolved executable -- `runPreflight` checks the file within each). */
+function managerBinDirs(deps) {
+    if (deps.platform === "win32")
+        return [];
+    const dirs = [];
+    for (const spec of MANAGER_DIRS) {
+        const envValue = deps.env[spec.envVar];
+        const root = envValue !== undefined && envValue !== ""
+            ? envValue
+            : path.posix.join(deps.homedir(), spec.defaultHome);
+        try {
+            const starIndex = spec.subpath.split("/").indexOf("*");
+            if (starIndex === -1) {
+                const candidate = path.posix.join(root, spec.subpath);
+                if (deps.exists(candidate))
+                    dirs.push(candidate);
+                continue;
+            }
+            const parts = spec.subpath.split("/");
+            const head = parts.slice(0, starIndex).join("/");
+            const tail = parts.slice(starIndex + 1).join("/");
+            const globRoot = path.posix.join(root, head);
+            const entries = [...deps.readdir(globRoot)].sort(compareVersionsNewestFirst);
+            for (const entry of entries) {
+                const candidate = path.posix.join(globRoot, entry, tail);
+                if (deps.exists(candidate))
+                    dirs.push(candidate);
+            }
+        }
+        catch {
+            // unreadable or missing -- simply not a candidate, never a throw (1.x's own guarantee).
+        }
+    }
+    return dirs;
+}
+
+/**
+ * The ordered preflight table (#55): 1.x's `PREREQS` (`preflight.py:114-174`) minus the install
+ * routes -- installing is never this agent's job, only the console's operator-facing "run this"
+ * instruction reads that far. Order is the Agents panel's Environment section's row order.
+ *
+ * `why` strings are 1.x's own (`:116-157`), verbatim -- they are the *consequence* of a tool's
+ * absence, not a restatement of its name, and this plan reuses them rather than re-deriving new
+ * wording that could quietly drift from what the 1.x Environment card has always said.
+ */
+const PREREQ_TABLE = [
+    {
+        cmd: "git",
+        label: "git",
+        required: true,
+        why: "every repo probe, the memory-sync commit/push, and repo discovery shell out to it; without it the console has no repo layer at all",
+    },
+    {
+        cmd: "gh",
+        label: "GitHub CLI",
+        required: true,
+        why: "every issue / label / PR / Actions-usage call. Presence alone is not enough -- it must also be authenticated (`gh auth login`), which the Environment card checks separately",
+    },
+    {
+        cmd: "node",
+        label: "Node.js",
+        required: true,
+        why: "the JS half of the test suite (vitest, plus the style.*.test.js node tests) cannot run locally without it, it builds the React shell bundle that ships in the wheel, and it is what `claude` installs through",
+    },
+    {
+        cmd: "claude",
+        label: "Claude Code CLI",
+        required: true,
+        why: "the spawned `claude -p` coding tasks, and the context-pressure / subagent-cost scans -- every console action that runs a headless Claude fails without it",
+    },
+    {
+        cmd: "chromium",
+        label: "PDF renderer (Chromium-family)",
+        required: false,
+        why: "the publish mirror's pdf/ output -- the phone / on-the-go read path; without it the HTML tree still syncs and no PDF is ever written",
+        altCmds: ["google-chrome", "google-chrome-stable", "chromium-browser", "microsoft-edge"],
+        winPaths: [
+            String.raw `C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe`,
+            String.raw `C:\Program Files\Microsoft\Edge\Application\msedge.exe`,
+            String.raw `C:\Program Files\Google\Chrome\Application\chrome.exe`,
+            String.raw `C:\Program Files (x86)\Google\Chrome\Application\chrome.exe`,
+        ],
+    },
+];
+
+const VERSION_TIMEOUT_MS = 15_000;
+function firstNonEmptyLine(text) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l !== "");
+    return lines[0] ?? "";
+}
+function lastNonEmptyLine(...texts) {
+    const lines = texts
+        .join("\n")
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l !== "");
+    return lines.at(-1) ?? "";
+}
+function shimDetail(entry) {
+    if (entry.cmd === "claude")
+        return "claude is a .cmd shim; install the native Claude Code binary";
+    if (entry.cmd === "gh")
+        return "gh is a .cmd shim; install the native GitHub CLI binary";
+    return `${entry.label} is a .cmd shim; install the native binary`;
+}
+function baseOf(entry) {
+    return { cmd: entry.cmd, label: entry.label, required: entry.required, why: entry.why };
+}
+/** The verdict once SOMETHING has been found at `foundPath` -- `onPath` distinguishes "usable as
+ *  it stands" (a winPaths hit, or found on the refreshed PATH: 1.x's `on_path=True`) from "found
+ *  only under a version manager" (`off-path` on success, never plain `ok`). `chromium` is never
+ *  executed regardless of which branch found it (E4 §5 decision 19; required: false keeps it
+ *  amber, never red, when it's missing instead). */
+async function verdictForFound(entry, deps, refreshedEnv, foundPath, onPath) {
+    const base = baseOf(entry);
+    if (entry.cmd === "chromium") {
+        return { ...base, status: "ok", path: foundPath, version: "", detail: "" };
+    }
+    const versionResult = await deps.run(foundPath, ["--version"], {
+        timeoutMs: VERSION_TIMEOUT_MS,
+        env: refreshedEnv,
+    });
+    if (versionResult.timedOut) {
+        return {
+            ...base,
+            status: "broken",
+            path: foundPath,
+            version: "",
+            detail: "timed out after 15 s",
+        };
+    }
+    if (versionResult.code !== 0) {
+        return {
+            ...base,
+            status: "broken",
+            path: foundPath,
+            version: "",
+            detail: lastNonEmptyLine(versionResult.stdout, versionResult.stderr),
+        };
+    }
+    const version = firstNonEmptyLine(versionResult.stdout);
+    if (entry.cmd === "gh") {
+        const authResult = await deps.run(foundPath, ["auth", "status"], {
+            timeoutMs: VERSION_TIMEOUT_MS,
+            env: refreshedEnv,
+        });
+        if (authResult.code !== 0) {
+            const stderrLine = lastNonEmptyLine(authResult.stderr);
+            return {
+                ...base,
+                status: "unauthenticated",
+                path: foundPath,
+                version,
+                detail: stderrLine === "" ? "run gh auth login" : `run gh auth login -- ${stderrLine}`,
+            };
+        }
+    }
+    return {
+        ...base,
+        status: onPath ? "ok" : "off-path",
+        path: foundPath,
+        version,
+        detail: onPath ? "" : "found under a version manager, not on PATH",
+    };
+}
+async function checkRowUnsafe(entry, deps, refreshedEnv) {
+    const base = baseOf(entry);
+    // 1. winPaths first -- an install-location hit is "usable as it stands" (1.x resolve_prereq).
+    for (const winPath of entry.winPaths ?? []) {
+        if (deps.exists(winPath)) {
+            return verdictForFound(entry, deps, refreshedEnv, winPath, true);
+        }
+    }
+    const names = [entry.cmd, ...(entry.altCmds ?? [])];
+    // 2. cmd + altCmds through which() on the refreshed PATH.
+    for (const name of names) {
+        const found = deps.which(name, refreshedEnv);
+        if (found.found) {
+            return verdictForFound(entry, deps, refreshedEnv, found.path, true);
+        }
+        if (found.reason === "shim") {
+            return { ...base, status: "broken", path: found.path, version: "", detail: shimDetail(entry) };
+        }
+    }
+    // 3. the same names as files under a version manager's bin directory -- off-PATH, not missing.
+    const dirs = managerBinDirs({
+        platform: deps.platform,
+        env: deps.env,
+        homedir: deps.homedir,
+        exists: deps.exists,
+        readdir: deps.readdir,
+    });
+    for (const name of names) {
+        for (const dir of dirs) {
+            const candidate = path.posix.join(dir, name);
+            if (deps.exists(candidate) && deps.isExecutable(candidate)) {
+                return verdictForFound(entry, deps, refreshedEnv, candidate, false);
+            }
+        }
+    }
+    return { ...base, status: "missing", path: "", version: "", detail: "" };
+}
+/** Wraps one row's whole resolution so a throwing `which`/`run`/`exists` becomes that row's own
+ *  `broken`, never a crash that takes the other four rows down with it (1.x
+ *  `tests/test_readiness.py:263`'s "a probe that raises becomes a row, not a crash"). */
+async function checkRow(entry, deps, refreshedEnv) {
+    try {
+        return await checkRowUnsafe(entry, deps, refreshedEnv);
+    }
+    catch (err) {
+        return {
+            ...baseOf(entry),
+            status: "broken",
+            path: "",
+            version: "",
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function runPreflight(deps) {
+    const resolved = await searchPath({ platform: deps.platform, env: deps.env, run: deps.run });
+    const refreshedEnv = { PATH: resolved.path };
+    const rows = await Promise.all(PREREQ_TABLE.map((entry) => checkRow(entry, deps, refreshedEnv)));
+    return {
+        machine: deps.machine,
+        checkedAt: deps.now().toISOString(),
+        searchPath: resolved.source,
+        rows,
+    };
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  runPreflight: runPreflight
+});
+
 export { AGENT_API_VERSION, dispatch, main };