@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/bin/cli.js

@@ -2,6 +2,9 @@
 
 const commandStartedAtMs = performance.timeOrigin + performance.now();
 const packageRoot = new URL("..", import.meta.url);
+// Invariant: one terminal module identity per process, decided before any A1 or Pi module loads.
+const [{ installPinnedPiTuiResolver }, { fileURLToPath: toPath }] = await Promise.all([import("./module-resolver.js"), import("node:url")]);
+installPinnedPiTuiResolver(toPath(packageRoot));
 const startup = await import("../dist/foundation/startup/startup-runtime.js");
 const startupProfile = process.argv[2] === "pi" ? "pi" : "a1";
 startup.initializeStartupTrace(process.env, startupProfile, commandStartedAtMs);
@@ -20,16 +23,12 @@ const capabilities = cliCapabilities(JSON.parse(await readFile(new URL("package.
 
 process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
-    const [{ prepareInteractiveLaunch }, { runBootstrap }, { healModuleIdentityAtLaunch, releaseCopyIsLaunchable }] = await Promise.all([
+    const [{ prepareInteractiveLaunch }, { runBootstrap }, { releaseCopyIsLaunchable }] = await Promise.all([
       import("../dist/features/launch/prepare-launch.js"),
       import("../dist/foundation/release/bootstrap.js"),
       import("./module-identity.js"),
     ]);
-    // Compatibility: self-heal the installed tree before the release store copies it: npm 12
-    // blocks install scripts by default, so the postinstall that normally
-    // repairs module identity may never have run (see bin/module-identity.js).
     const packageRootPath = fileURLToPath(packageRoot);
-    await healModuleIdentityAtLaunch(packageRootPath, message => process.stderr.write(message));
     const prepared = await prepareInteractiveLaunch(intent);
     return await runBootstrap({
       packageRoot: packageRootPath,

package/bin/guardian.js

@@ -11,9 +11,13 @@ const { readLaunchContext } = await import("../dist/foundation/launch-context/in
 const launchContext = readLaunchContext(process.env, "release");
 const releaseRoot = launchContext.releaseRoot;
 const profileId = readLaunchContext(process.env, "profile").launchProfile;
+// Invariant: the "release" and "profile" requirements above already refused an environment without
+// these values; the checks give the type checker the same certainty.
+if (releaseRoot === undefined || profileId === undefined) throw new Error("A1 launch context is incomplete");
 
+const sessionSelection = parseSessionSelection(process.argv.slice(2));
 Promise.resolve().then(() => runLaunchGuardian({
-  sessionSelection: parseSessionSelection(process.argv.slice(2)),
+  ...(sessionSelection === undefined ? {} : { sessionSelection }),
   profileId,
   releaseRoot,
   uiEntry: resolve(releaseRoot, "bin", "ui.js"),

package/bin/module-identity.js

@@ -1,101 +1,58 @@
 /**
- * One pi-tui module identity per process.
+ * One pi-tui module identity per process: the check that the resolver hook worked.
  *
- * npm materializes @earendil-works/pi-tui twice under A1's package root: once
- * as A1's direct dependency at the node_modules root, and once nested inside
- * @earendil-works/pi-coding-agent, whose published npm-shrinkwrap.json makes
- * npm build its dependency tree exactly as shrinkwrapped instead of sharing a
- * hoisted copy. Both are the same version; npm just cannot tell them apart.
+ * bin/module-resolver.js decides identity at the loader by rewriting every pi-tui module
+ * URL to the copy pinned Pi resolves. What remains here is the assertion, made by asking
+ * Node itself: with the hook installed, resolving `@earendil-works/pi-tui` from A1's own
+ * package root must answer with the same real path pinned Pi answers with. When it does not,
+ * launch says so loudly and once, instead of leaving a user to discover it as missing
+ * extension UI.
  *
- * Two copies means two of every TUI class. Pinned Pi hands extensions the
- * nested copy — its extension loader aliases the specifier to whatever it
- * resolves from its own directory — so an extension's `instanceof` check and
- * its prototype patches land on classes A1's renderer never uses. Extension
- * chrome silently disappears and routed input dead-ends, with no error.
- *
- * A1 therefore does not import the specifier at all. Its package declares the
- * subpath import `#pi-tui`, resolving to bin/pi-tui.js — a proxy that
- * re-exports pinned Pi's nested copy. The hop through the proxy is load-bearing:
- * Node rejects package-imports targets containing a `node_modules` path segment
- * (Invalid Package Target) and silently falls through to any fallback, which is
- * exactly how an earlier alias that named the nested path directly reintroduced
- * the split while appearing to declare the opposite. A plain import specifier
- * inside a module carries no such restriction.
- *
- * What remains here is the check that it worked. The alias is resolved by
- * asking Node itself — never by reimplementing resolution, which is how the
- * earlier check reported "unified" for a target Node had rejected — and the
- * proxy hop is followed to the module it re-exports. When that disagrees with
- * what pinned Pi resolves, launch says so, loudly and once, instead of leaving
- * a user to discover it as missing extension UI.
- *
- * This lives in bin/ (shipped, plain JS) because it inspects dependency
- * resolution, which the Pi API boundary policy rightly forbids ordinary
- * production code from touching.
+ * This lives in bin/ (shipped, plain JS) because it inspects dependency resolution, which
+ * the Pi API boundary policy rightly forbids ordinary production code from touching.
  */
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { pinnedPiTuiPackageRoot } from "./module-resolver.js";
 
 /**
- * What A1's own modules resolve `#pi-tui` to, as a real path.
- *
- * Node answers for the alias itself (require.resolve honors package imports for
- * the package the parent belongs to). When the answer is A1's proxy file, the
- * module it re-exports is what A1 actually renders with, so the proxy's one
- * static `export * from` specifier is followed to its target.
+ * @typedef {{ kind: "unified"; path: string } | { kind: "split"; own: string; pinned: string } | { kind: "unresolved"; side: "a1" | "pi"; message: string }} ModuleIdentityOutcome
  */
-function resolveOwnPiTui(packageRoot) {
-  const requireFromRoot = createRequire(pathToFileURL(join(packageRoot, "package.json")).href);
-  let resolved;
-  try {
-    resolved = requireFromRoot.resolve("#pi-tui");
-  } catch (error) {
-    throw new Error(`#pi-tui does not resolve: ${message(error)}`);
-  }
-  return canonical(followProxyReExport(resolved));
-}
+
+
+const OWN_PACKAGE_ROOT = canonical(fileURLToPath(new URL("..", import.meta.url)));
 
 /**
- * Follow A1's proxy hop: one relative `export * from "..."` per file, at most
- * one hop. A resolution that is not the proxy (or any file without such a
- * re-export) is returned as-is.
+ * What A1's own modules resolve `@earendil-works/pi-tui` to, as a real path.
+ *
+ * Compatibility: the resolver hook governs ESM loading, and on Node 22 CommonJS resolution does
+ * not consult synchronous hooks at all, so the process's own package is measured through the ESM
+ * resolver from this file, which sits in that package. Any other root is measured by plain
+ * resolution, which is what its own entries would see before installing the hook. A test
+ * transformer that offers no `import.meta.resolve` falls back to plain resolution too.
+ * @param {string} packageRoot
  */
-function followProxyReExport(resolvedPath) {
-  let source;
-  try {
-    source = readFileSync(resolvedPath, "utf8");
-  } catch {
-    return resolvedPath;
-  }
-  const reExport = source.match(/^export \* from "(\.\.?\/[^"]+)";?$/m);
-  if (!reExport) return resolvedPath;
-  const target = join(dirname(resolvedPath), reExport[1]);
-  if (!existsSync(target)) {
-    throw new Error(`#pi-tui proxy ${resolvedPath} re-exports a missing file: ${target}`);
+function resolveOwnPiTui(packageRoot) {
+  if (canonical(packageRoot) === OWN_PACKAGE_ROOT && typeof import.meta.resolve === "function") {
+    return canonical(fileURLToPath(import.meta.resolve("@earendil-works/pi-tui")));
   }
-  return target;
+  const requireFromRoot = createRequire(pathToFileURL(join(packageRoot, "package.json")).href);
+  return canonical(requireFromRoot.resolve("@earendil-works/pi-tui"));
 }
 
 /**
- * What pinned Pi resolves the same specifier to, as a real path — asked from
- * inside Pi's own directory, which is where Pi asks it.
- *
- * Pi's directory is located by walking node_modules outward, the way Node
- * itself would, rather than by resolving Pi's entry: its `exports` map offers
- * no CommonJS condition, so an ordinary require cannot name it. From there a
- * require resolves pi-tui, which publishes no `exports` map at all.
+ * What pinned Pi resolves `@earendil-works/pi-tui` to, as a real path.
+ * @param {string} packageRoot
  */
 export function resolvePinnedPiTui(packageRoot) {
-  const pinnedRoot = resolvePinnedPiRoot(packageRoot);
-  return canonical(createRequire(pathToFileURL(join(pinnedRoot, "package.json")).href).resolve("@earendil-works/pi-tui"));
+  return canonical(join(pinnedPiTuiPackageRoot(packageRoot), "dist", "index.js"));
 }
 
 /**
- * Bind Pi's documented package-asset override to the exact public package root.
- * The generated startup facade otherwise inherits its own A1 `import.meta.url`,
- * which would make Pi read A1's package metadata and themes.
+ * @param {string} packageRoot
+ * @param {NodeJS.ProcessEnv} [environment]
  */
 export function configurePinnedPiPublicPackage(packageRoot, environment = process.env) {
   const pinnedRoot = resolvePinnedPiRoot(packageRoot);
@@ -107,6 +64,7 @@ export function configurePinnedPiPublicPackage(packageRoot, environment = proces
   return { root: pinnedRoot, version: manifest.version };
 }
 
+/** @param {string} packageRoot */
 function resolvePinnedPiRoot(packageRoot) {
   let directory = packageRoot;
   while (true) {
@@ -118,6 +76,7 @@ function resolvePinnedPiRoot(packageRoot) {
   }
 }
 
+/** @param {string} path */
 function canonical(path) {
   try {
     return realpathSync.native(path);
@@ -127,8 +86,10 @@ function canonical(path) {
 }
 
 /**
- * Report whether A1 and pinned Pi resolve pi-tui to the same file.
- * Returns a discriminated outcome; never throws.
+ * Compare what A1 and pinned Pi resolve. With the resolver hook installed in this process the
+ * two agree whatever layout npm built; without it they agree only when npm hoisted one copy.
+ * @param {string} packageRoot
+ * @returns {ModuleIdentityOutcome}
  */
 export function inspectPiTuiModuleIdentity(packageRoot) {
   let own;
@@ -146,38 +107,32 @@ export function inspectPiTuiModuleIdentity(packageRoot) {
   return own === pinned ? { kind: "unified", path: own } : { kind: "split", own, pinned };
 }
 
+/** @param {unknown} error */
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 /**
- * Launch-entry self-heal: when A1 and pinned Pi disagree on the terminal
- * module, rewrite the proxy to the copy Pi resolves before anything copies
- * this tree. npm 12 blocks install scripts unless allowScripts covers the
- * package, so the postinstall that normally rewrites the proxy may never
- * have run and the installed tree may still carry the published placeholder
- * path. Named neutrally so the launch entries that call it stay free of
- * terminal implementation identifiers, as the bootstrap boundary requires.
+ * A release copy is launchable when pinned Pi inside it resolves its terminal package.
+ * @param {string} releaseRoot
  */
-export async function healModuleIdentityAtLaunch(packageRoot, warn) {
-  if (inspectPiTuiModuleIdentity(packageRoot).kind === "unified") return;
-  const { syncPiTuiProxy } = await import("./sync-pi-tui-proxy.js");
-  const outcome = syncPiTuiProxy(packageRoot);
-  if (outcome.kind === "unresolved") {
-    warn(`a1: could not point the terminal module proxy at pinned Pi's copy (${outcome.message}); extension UI may not render.\n`);
-  }
-}
-
-/** Whether a materialized release copy resolves one terminal module for both A1 and Pi. */
 export function releaseCopyIsLaunchable(releaseRoot) {
-  return inspectPiTuiModuleIdentity(releaseRoot).kind === "unified";
+  try {
+    resolvePinnedPiTui(releaseRoot);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-/** Launch-entry wrapper: warn on stderr when the two sides disagree. */
+/**
+ * @param {string} packageRoot
+ * @param {(message: string) => void} warn
+ */
 export function assertSinglePiTuiModuleAtLaunch(packageRoot, warn) {
   const outcome = inspectPiTuiModuleIdentity(packageRoot);
   if (outcome.kind === "split") {
-    warn(`a1: pi-tui resolves to two different copies (${outcome.own} for a1, ${outcome.pinned} for Pi); extension UI may not render. The #pi-tui alias in a1's package.json no longer names Pi's copy.\n`);
+    warn(`a1: pi-tui resolves to two different copies (${outcome.own} for a1, ${outcome.pinned} for Pi); extension UI may not render. The pinned pi-tui resolver hook is not active in this process.\n`);
   } else if (outcome.kind === "unresolved") {
     warn(`a1: could not resolve pi-tui from ${outcome.side === "a1" ? "a1" : "pinned Pi"} (${outcome.message}); extension UI may not render.\n`);
   }

package/bin/module-resolver.js

@@ -0,0 +1,138 @@
+/**
+ * One pi-tui module identity per process, decided at the loader.
+ *
+ * npm may materialize @earendil-works/pi-tui twice under A1's package root: as A1's own
+ * dependency at the node_modules root and nested inside @earendil-works/pi-coding-agent,
+ * whose shrinkwrap pins its own copy. Two copies means two of every TUI class: pinned Pi
+ * hands extensions the copy it resolves itself, so an extension's `instanceof` check and
+ * prototype patches would land on classes A1's renderer never uses, and extension chrome
+ * would silently vanish.
+ *
+ * Rather than repairing the layout after the fact, this module asks Node which copy pinned
+ * Pi resolves and installs a synchronous resolve hook that rewrites every pi-tui module URL,
+ * from any importer and in any form (bare specifier, subpath, or an absolute path into the
+ * other copy), to that one copy. When npm hoisted a single copy the two answers coincide and
+ * the hook changes nothing. The hook is registered by the bin/ entries before any A1 module
+ * loads, so the composition, the bundled Pi public artifact, and Pi's own extension loader
+ * all share one module. bin/module-identity.js keeps the launch-time assertion that it
+ * worked.
+ *
+ * This lives in bin/ (shipped, plain JS) because it inspects dependency resolution, which
+ * the Pi API boundary policy rightly forbids ordinary production code from touching.
+ */
+import { createRequire, registerHooks } from "node:module";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const PACKAGE = "@earendil-works/pi-tui";
+const SEGMENT = `/node_modules/${PACKAGE}/`;
+
+/** @type {string | null} */
+let installed = null;
+
+/**
+ * The package root pinned Pi resolves `@earendil-works/pi-tui` to, as a real path.
+ * @param {string} packageRoot
+ * @returns {string}
+ */
+export function pinnedPiTuiPackageRoot(packageRoot) {
+  return pinnedPiTuiLayout(packageRoot).pinnedRoot;
+}
+
+/**
+ * Where pinned Pi lives and which pi-tui copy it resolves. The installation root is the directory
+ * whose node_modules holds pinned Pi; the hook rewrites only modules beneath it, so fixture trees
+ * and other release copies inspected from this process keep their own resolution.
+ * @param {string} packageRoot
+ * @returns {{ installationRoot: string; pinnedRoot: string }}
+ */
+export function pinnedPiTuiLayout(packageRoot) {
+  const piRoot = pinnedPiRoot(packageRoot);
+  const requireFromPi = createRequire(pathToFileURL(join(piRoot, "package.json")).href);
+  return {
+    installationRoot: dirname(dirname(dirname(piRoot))),
+    pinnedRoot: packageRootOf(canonical(requireFromPi.resolve(PACKAGE))),
+  };
+}
+
+// Rationale: pinned Pi exports no `./package.json` subpath, so its directory is found by walking
+// up from the package root the way Node itself would, never by reimplementing export resolution.
+/** @param {string} packageRoot */
+function pinnedPiRoot(packageRoot) {
+  let directory = packageRoot;
+  while (true) {
+    const candidate = join(directory, "node_modules", "@earendil-works", "pi-coding-agent");
+    if (existsSync(join(candidate, "package.json"))) return canonical(candidate);
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error("pinned Pi is not installed beneath this package root");
+    directory = parent;
+  }
+}
+
+/**
+ * Install the resolve hook once per process. Returns the pinned package root URL. Idempotent:
+ * every bin/ entry calls it and only the first call registers.
+ * @param {string} packageRoot
+ * @returns {string}
+ */
+export function installPinnedPiTuiResolver(packageRoot) {
+  if (installed !== null) return installed;
+  const layout = pinnedPiTuiLayout(packageRoot);
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      const result = nextResolve(specifier, context);
+      const rewritten = redirectToPinned(result.url, layout);
+      return rewritten === result.url ? result : { ...result, url: rewritten };
+    },
+  });
+  installed = pathToFileURL(layout.pinnedRoot).href.replace(/\/$/, "");
+  return installed;
+}
+
+/**
+ * Rewrite a resolved pi-tui module URL beneath the installation root to the pinned copy; any
+ * other URL is returned unchanged. Paths are compared as canonical real paths, never as URL
+ * strings: a temp directory reached by its short 8.3 name or a different drive-letter case is
+ * still the same installation.
+ * @param {string} url
+ * @param {{ installationRoot: string; pinnedRoot: string }} layout
+ * @returns {string}
+ */
+export function redirectToPinned(url, layout) {
+  if (!url.startsWith("file:")) return url;
+  const index = url.lastIndexOf(SEGMENT);
+  if (index < 0) return url;
+  const packagePath = canonical(fileURLToPath(url.slice(0, index + SEGMENT.length - 1)));
+  if (packagePath === layout.pinnedRoot || !isWithin(layout.installationRoot, packagePath)) return url;
+  return `${pathToFileURL(layout.pinnedRoot).href.replace(/\/$/, "")}${url.slice(index + SEGMENT.length - 1)}`;
+}
+
+/**
+ * @param {string} root
+ * @param {string} path
+ */
+function isWithin(root, path) {
+  const relativePath = relative(root, path);
+  return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+
+/** @param {string} path */
+function canonical(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+/** @param {string} modulePath */
+function packageRootOf(modulePath) {
+  let directory = dirname(modulePath);
+  while (!directory.endsWith(join("node_modules", "@earendil-works", "pi-tui"))) {
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error(`${modulePath} is not inside a ${PACKAGE} package`);
+    directory = parent;
+  }
+  return directory;
+}

package/bin/pinned-pi-public.js

@@ -2,7 +2,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, posix, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-/** Bind the generated facade to the package reached through Pi's public entry. */
+/**
+ * Bind the generated facade to the package reached through Pi's public entry.
+ * @param {string | URL} entryUrl
+ */
 export function configurePinnedPiPublicPackageEntry(entryUrl) {
   const root = dirname(dirname(fileURLToPath(entryUrl)));
   const manifest = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
@@ -13,7 +16,10 @@ export function configurePinnedPiPublicPackageEntry(entryUrl) {
   return { root, version: manifest.version };
 }
 
-/** Preserve one bundled Pi module's original public-package URL semantics. */
+/**
+ * Preserve one bundled Pi module's original public-package URL semantics.
+ * @param {string} relativeModule
+ */
 export function pinnedPiModuleUrl(relativeModule) {
   if (typeof relativeModule !== "string" || relativeModule.includes("\\") || relativeModule.startsWith("/")
     || posix.normalize(relativeModule).startsWith("../") || !relativeModule.endsWith(".js")) {
@@ -22,7 +28,10 @@ export function pinnedPiModuleUrl(relativeModule) {
   return pathToFileURL(resolve(pinnedRoot(), "dist", relativeModule)).href;
 }
 
-/** Resolve documented Pi dependency exports from the pinned public package tree. */
+/**
+ * Resolve documented Pi dependency exports from the pinned public package tree.
+ * @param {string} specifier
+ */
 export function resolvePinnedPiImport(specifier) {
   if (typeof specifier !== "string" || specifier.includes("\\") || specifier.includes("\0")) {
     throw new Error("pinned Pi import specifier is invalid");
@@ -31,7 +40,7 @@ export function resolvePinnedPiImport(specifier) {
   if (specifier === "@earendil-works/pi-coding-agent") return pathToFileURL(resolve(root, "dist", "index.js")).href;
   const match = /^(@[^/]+\/[^/]+|[^/]+)(\/.*)?$/.exec(specifier);
   if (match === null) throw new Error(`pinned Pi import is invalid: ${specifier}`);
-  const packageName = match[1];
+  const packageName = match[1] ?? "";
   const subpath = match[2]?.slice(1) ?? "";
   const packageRoot = resolve(root, "node_modules", ...packageName.split("/"));
   const manifestPath = resolve(packageRoot, "package.json");
@@ -51,11 +60,16 @@ function pinnedRoot() {
   return resolve(root);
 }
 
+/**
+ * @param {unknown} exports
+ * @param {string} subpath
+ * @returns {string | undefined}
+ */
 function exportedTarget(exports, subpath) {
   const key = subpath.length === 0 ? "." : `./${subpath}`;
   if (typeof exports === "string") return subpath.length === 0 ? exports : undefined;
   if (!exports || typeof exports !== "object") return undefined;
-  const exact = exports[key];
+  const exact = /** @type {Record<string, unknown>} */ (exports)[key];
   if (exact !== undefined) return importCondition(exact);
   for (const [pattern, value] of Object.entries(exports)) {
     const star = pattern.indexOf("*");
@@ -67,8 +81,13 @@ function exportedTarget(exports, subpath) {
   return undefined;
 }
 
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
 function importCondition(value) {
   if (typeof value === "string") return value;
   if (!value || typeof value !== "object") return undefined;
-  return importCondition(value.import ?? value.default);
+  const conditions = /** @type {{ import?: unknown; default?: unknown }} */ (value);
+  return importCondition(conditions.import ?? conditions.default);
 }

package/bin/ui.js

@@ -1,17 +1,22 @@
 #!/usr/bin/env node
 
+// Invariant: one terminal module identity per process, decided before any A1 or Pi module loads.
+const { installPinnedPiTuiResolver } = await import("./module-resolver.js");
+installPinnedPiTuiResolver(new URL("..", import.meta.url).pathname.replace(/^\/(.:)/, "$1").replace(/\/$/, ""));
 const startup = await import("../dist/foundation/startup/startup-runtime.js");
 startup.enableEnvironmentCompileCache(process.env);
 const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
 const launchContext = readLaunchContext(process.env, "profile");
 const profile = launchContext.launchProfile;
+if (profile === undefined) throw new Error("A1 launch profile is missing");
 const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/fatal-exit.js");
 const { resolveProductPaths } = await import("../dist/foundation/lifecycle/paths.js");
 const { join } = await import("node:path");
+/** @type {{ dispose(): void | Promise<unknown> } | undefined} */
 let runningApplication;
 const fatal = profile === "a1" ? installFatalExit({
   directory: join(resolveProductPaths().runtimeDir, "crashes"),
-  releaseId: launchContext.releaseId,
+  ...(launchContext.releaseId === undefined ? {} : { releaseId: launchContext.releaseId }),
   dispose: () => runningApplication?.dispose(),
 }) : undefined;
 const [{ fileURLToPath }, identity, descriptor] = await Promise.all([
@@ -36,7 +41,7 @@ const [
 
 // Compatibility: before the composition uses pinned Pi's terminal stack: confirm A1 and Pi
 // resolve it to the same copy, so extensions and the owned UI share one module identity.
-identity.assertSinglePiTuiModuleAtLaunch(packageRootPath, message => process.stderr.write(message));
+identity.assertSinglePiTuiModuleAtLaunch(packageRootPath, (/** @type {string} */ message) => process.stderr.write(message));
 await startup.markStartupPhase(process.env, "ui-modules-loaded");
 
 const sessionSelection = parseSessionSelection(process.argv.slice(2));