@timurproko/a1 0.1.8-dev.132 → 0.1.8-dev.136

package/bin/cli.js

@@ -11,12 +11,23 @@ const capabilities = cliCapabilities(JSON.parse(await readFile(new URL("package.
 
 process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
-    const [{ prepareInteractiveLaunch }, { runBootstrap }] = await Promise.all([
+    const [{ prepareInteractiveLaunch }, { runBootstrap }, { healModuleIdentityAtLaunch, releaseCopyIsLaunchable }] = await Promise.all([
       import("../dist/features/launch/index.js"),
       import("../dist/foundation/release/index.js"),
+      import("./module-identity.js"),
     ]);
+    // 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: fileURLToPath(packageRoot), launchIntent: intent, environment: prepared.environment });
+    return await runBootstrap({
+      packageRoot: packageRootPath,
+      launchIntent: intent,
+      environment: prepared.environment,
+      releaseIsLaunchable: releaseCopyIsLaunchable,
+    });
   },
   version: async () => {
     const { runVersionStats } = await import("../dist/cli/index.js");

package/bin/module-identity.js

@@ -87,7 +87,7 @@ function followProxyReExport(resolvedPath) {
  * no CommonJS condition, so an ordinary require cannot name it. From there a
  * require resolves pi-tui, which publishes no `exports` map at all.
  */
-function resolvePinnedPiTui(packageRoot) {
+export function resolvePinnedPiTui(packageRoot) {
   let directory = packageRoot;
   while (true) {
     const candidate = join(directory, "node_modules", "@earendil-works", "pi-coding-agent");
@@ -132,6 +132,29 @@ 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.
+ */
+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";
+}
+
 /** Launch-entry wrapper: warn on stderr when the two sides disagree. */
 export function assertSinglePiTuiModuleAtLaunch(packageRoot, warn) {
   const outcome = inspectPiTuiModuleIdentity(packageRoot);

package/bin/pi-tui.d.ts

@@ -3,4 +3,4 @@
  * file, so TypeScript reads this declaration and follows it to pinned Pi's
  * nested pi-tui copy — the same module the proxy re-exports at runtime.
  */
-export * from "../node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/index.js";
+export * from "../node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/index.d.ts";

package/bin/pi-tui.js

@@ -12,10 +12,14 @@
  * plain import specifier in a module carries no such restriction, so the hop
  * through this file is what makes the nested copy nameable from the manifest.
  *
- * When the nested copy is missing (a layout pinned Pi's shrinkwrap does not
- * produce), this import fails loudly at launch instead of silently rendering
- * without extension chrome. bin/module-identity.js reports the same condition
- * before the composition loads.
+ * npm does not materialize one layout: `npm ci` keeps pinned Pi's shrinkwrapped
+ * nested copy, while a global install hoists pi-tui to the root and produces no
+ * nested copy. bin/sync-pi-tui-proxy.js therefore rewrites this file's one
+ * re-export on postinstall to whatever pinned Pi resolves in the tree npm
+ * actually built; the path below is the dev-checkout (`npm ci`) shape. When the
+ * target is missing anyway, this import fails loudly at launch instead of
+ * silently rendering without extension chrome, and bin/module-identity.js
+ * reports the same condition before the composition loads.
  *
  * This lives in bin/ (shipped, plain JS) because it names a path inside
  * node_modules, which the Pi API boundary policy rightly forbids ordinary

package/bin/sync-pi-tui-proxy.js

@@ -0,0 +1,97 @@
+/**
+ * Point the `#pi-tui` proxy at the copy pinned Pi actually resolves.
+ *
+ * The proxy (bin/pi-tui.js) re-exports one static path, but npm does not
+ * materialize one layout: `npm ci` against A1's lockfile keeps pinned Pi's
+ * shrinkwrapped nested pi-tui copy, while a global `npm install -g` of the
+ * published tarball hoists pi-tui to A1's node_modules root and materializes
+ * no nested copy at all. A static path can only name one of those layouts —
+ * whichever the other layout lacks, the proxy's import fails at launch and
+ * extension UI never renders.
+ *
+ * This script runs on postinstall, asks Node what pinned Pi resolves
+ * `@earendil-works/pi-tui` to — the copy Pi's extension loader hands to
+ * extensions — and rewrites the proxy's single re-export (and its declaration
+ * twin) to that file. Whatever tree npm built, the proxy names the module Pi
+ * uses, so A1's renderer and Pi's extensions share one class identity.
+ *
+ * It never fails an install: a tree in which pinned Pi or its pi-tui cannot
+ * be resolved is reported on stderr and left untouched, and launch's
+ * module-identity check names the same condition to the user.
+ *
+ * This lives in bin/ (shipped, plain JS) because it inspects and names
+ * dependency resolution, which the Pi API boundary policy rightly forbids
+ * ordinary production code from touching.
+ */
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolvePinnedPiTui } from "./module-identity.js";
+
+const RE_EXPORT_LINE = /^export \* from "[^"]+";$/m;
+
+/**
+ * Rewrite the proxy pair under packageRoot/bin to re-export the pi-tui module
+ * pinned Pi resolves. Returns a discriminated outcome; never throws.
+ */
+export function syncPiTuiProxy(packageRoot) {
+  // resolvePinnedPiTui answers with a canonical real path, so the directory the
+  // relative specifier is computed from must be canonical too (Windows short
+  // names, symlinked installs).
+  const canonicalRoot = canonical(packageRoot);
+  let target;
+  try {
+    target = resolvePinnedPiTui(canonicalRoot);
+  } catch (error) {
+    return { kind: "unresolved", message: error instanceof Error ? error.message : String(error) };
+  }
+
+  const binDirectory = join(canonicalRoot, "bin");
+  const runtimeSpecifier = relativeSpecifier(binDirectory, target);
+  const declarationSpecifier = runtimeSpecifier.replace(/\.js$/, ".d.ts").replace(/\.d\.d\.ts$/, ".d.ts");
+  const changed = [];
+  for (const [file, specifier] of [
+    ["pi-tui.js", runtimeSpecifier],
+    ["pi-tui.d.ts", declarationSpecifier],
+  ]) {
+    if (rewriteReExport(join(binDirectory, file), specifier)) changed.push(file);
+  }
+  return { kind: "synced", target, changed };
+}
+
+function canonical(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+function relativeSpecifier(fromDirectory, toFile) {
+  const specifier = relative(fromDirectory, toFile).split("\\").join("/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+
+/** Replace the file's single re-export line; returns whether the file changed. */
+function rewriteReExport(file, specifier) {
+  let source;
+  try {
+    source = readFileSync(file, "utf8");
+  } catch {
+    return false;
+  }
+  const line = `export * from "${specifier}";`;
+  if (source.includes(line) || !RE_EXPORT_LINE.test(source)) return false;
+  writeFileSync(file, source.replace(RE_EXPORT_LINE, line));
+  return true;
+}
+
+const invokedDirectly = process.argv[1] !== undefined
+  && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedDirectly) {
+  const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  const outcome = syncPiTuiProxy(packageRoot);
+  if (outcome.kind === "unresolved") {
+    process.stderr.write(`a1: could not point #pi-tui at pinned Pi's copy (${outcome.message}); extension UI may not render.\n`);
+  }
+}

package/dist/cli/version-stats.d.ts

@@ -3,6 +3,11 @@ interface VersionProcessResult {
     readonly stdout: string;
 }
 type VersionProcessRunner = (command: string, arguments_: readonly string[]) => Promise<VersionProcessResult>;
+type RegistryFetcher = (url: string) => Promise<{
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+}>;
 interface VersionOutput {
     stdout(message: string): void;
     stderr(message: string): void;
@@ -11,6 +16,7 @@ export interface VersionStatsOptions {
     readonly packageRoot: string;
     readonly output?: VersionOutput;
     readonly runner?: VersionProcessRunner;
+    readonly fetcher?: RegistryFetcher;
 }
 export declare function runVersionStats(options: VersionStatsOptions): Promise<number>;
 export {};

package/dist/cli/version-stats.js

@@ -20,13 +20,24 @@ export async function runVersionStats(options) {
         output.stderr(`${PRODUCT_TEXT.diagnostic(`could not read its installed version: ${message(error)}`)}\n`);
         return 1;
     }
-    const remote = await queryDistTags(runner);
+    const remote = await queryDistTags(runner, options.fetcher ?? defaultRegistryFetcher);
     output.stdout(`Current: ${installed}\nDevelop: ${remote.develop ?? "unavailable"}\nRelease: ${remote.release ?? "unavailable"}\n`);
     if (remote.error)
         output.stderr(`${PRODUCT_TEXT.diagnostic(`could not resolve npm dist-tags: ${remote.error}`)}\n`);
     return 0;
 }
-async function queryDistTags(runner) {
+// npm view respects the user's .npmrc registry and proxy, so it stays primary; the direct
+// registry fetch below covers npm CLI versions whose --json output shape we cannot parse.
+async function queryDistTags(runner, fetcher) {
+    const fromNpm = await queryDistTagsViaNpm(runner);
+    if (fromNpm.error === null)
+        return fromNpm;
+    const fromRegistry = await queryDistTagsViaRegistry(fetcher);
+    if (fromRegistry.error === null)
+        return fromRegistry;
+    return unavailable(`${fromNpm.error}; registry fallback failed: ${fromRegistry.error}`);
+}
+async function queryDistTagsViaNpm(runner) {
     let result;
     try {
         result = await runner("npm", ["view", PRODUCT_TEXT.packageName, "dist-tags", "--json"]);
@@ -40,11 +51,31 @@ async function queryDistTags(runner) {
         const parsed = JSON.parse(result.stdout);
         // npm 12 wraps `npm view <pkg> dist-tags --json` output in a one-element array; older npm returns the bare object.
         const metadata = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
-        if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
-            throw new TypeError("npm returned a non-object dist-tags value");
+        return parseDistTags(metadata, "npm");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+async function queryDistTagsViaRegistry(fetcher) {
+    try {
+        const response = await fetcher(`https://registry.npmjs.org/-/package/${encodeURIComponent(PRODUCT_TEXT.packageName)}/dist-tags`);
+        if (!response.ok)
+            return unavailable(`registry responded with status ${response.status}`);
+        return parseDistTags(JSON.parse(await response.text()), "registry");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+function parseDistTags(metadata, source) {
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return unavailable(`${source} returned a non-object dist-tags value`);
+    }
+    try {
         const tags = metadata;
-        const release = parseVersion(tags.latest, "npm latest");
-        const develop = tags.next === undefined ? null : parseVersion(tags.next, "npm development channel");
+        const release = parseVersion(tags.latest, `${source} latest`);
+        const develop = tags.next === undefined ? null : parseVersion(tags.next, `${source} development channel`);
         return { release, develop, error: null };
     }
     catch (error) {
@@ -54,6 +85,7 @@ async function queryDistTags(runner) {
 function unavailable(error) {
     return { release: null, develop: null, error };
 }
+const defaultRegistryFetcher = async (url) => await fetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
 function createVersionProcessRunner() {
     return async (command, arguments_) => await new Promise((resolvePromise, rejectPromise) => {
         const child = process.platform === "win32"

package/dist/foundation/release/bootstrap.d.ts

@@ -13,6 +13,16 @@ export interface BootstrapOptions {
     };
     readonly environment?: NodeJS.ProcessEnv;
     readonly output?: Pick<NodeJS.WriteStream, "write">;
+    /**
+     * Whether a materialized release copy is fit to launch. The active release
+     * is normally reused while its version matches the installation, but a copy
+     * can be broken in ways a version cannot see — materialized from a tree a
+     * blocked postinstall never finished repairing. The probe is injected from
+     * the bin entry because deciding it requires inspecting dependency
+     * resolution, which stays out of production code. Absent means every
+     * release is fit.
+     */
+    readonly releaseIsLaunchable?: (releaseRoot: string) => boolean;
 }
 export declare function runBootstrap(options: BootstrapOptions): Promise<number>;
 export declare function certifyMaterializedRelease(release: MaterializedRelease, dataDir: string, verification?: VerifyMaterializedReleaseOptions): Promise<string>;

package/dist/foundation/release/bootstrap.js

@@ -46,7 +46,11 @@ export async function runBootstrap(options) {
     const installedVersion = await readInstalledVersion(options.packageRoot);
     const activeId = state.references.active;
     const active = activeId === null ? undefined : state.releases[activeId];
-    if (active?.approval === "approved" && active.packageVersion === installedVersion) {
+    const activeIsLaunchable = active === undefined || (options.releaseIsLaunchable?.(active.releaseRoot) ?? true);
+    if (active !== undefined && !activeIsLaunchable) {
+        output.write(`${PRODUCT_TEXT.diagnostic(`retired release ${active.releaseId} because its copy is not launchable; rebuilding from the installed package.`)}\n`);
+    }
+    if (activeIsLaunchable && active?.approval === "approved" && active.packageVersion === installedVersion) {
         const endpointMatches = endpoint?.releaseId === active.releaseId
             && endpoint.releaseRoot === active.releaseRoot
             && endpoint.contentDigest === active.contentDigest;

package/dist/foundation/release/update.js

@@ -403,6 +403,19 @@ export async function runSelfUpdate(options) {
             }
             transaction = await transactionStore.advance("package-installed");
         }
+        // npm 12 blocks install scripts unless allowScripts covers the package, so
+        // the postinstall that points the #pi-tui proxy at the tree npm just built
+        // may never have run. Run the shipped script directly: the proxy must be
+        // correct before the release store copies this tree. A failure is reported
+        // and left to the launch-time self-heal rather than failing the update.
+        try {
+            const proxySync = await runner(process.execPath, [resolve(packageRoot, "bin", "sync-pi-tui-proxy.js")], { captureStdout: true });
+            if (proxySync.code !== 0)
+                output.stderr(`${PRODUCT_TEXT.diagnostic(`could not point the #pi-tui proxy at the installed tree (exited ${formatExitCode(proxySync.code)}).`)}\n`);
+        }
+        catch (error) {
+            output.stderr(`${PRODUCT_TEXT.diagnostic(`could not point the #pi-tui proxy at the installed tree: ${errorMessage(error)}`)}\n`);
+        }
         progress.set(70, 75);
         // Ownership can be reacquired after an interrupted installation (for
         // example, if bare A1 is launched before the update is resumed). Recheck

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-25T17:36:44.842Z",
+  "builtAt": "2026-08-26T05:59:16.405Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T17:37:08.874Z",
+  "builtAt": "2026-08-26T05:59:26.040Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T17:37:16.993Z",
+  "builtAt": "2026-08-26T05:59:44.317Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "b9edc03a251b1c0e851ff55227385f016241fc4f33aa0f5ee5f0415443d6a927",
+    "sha256": "f36f8c76d82ce8e3d163c7671868bd0ab8b7bc1e14a190714aaeb304b2116a5b",
     "size": 172544
   },
   "provenance": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.132",
+  "version": "0.1.8-dev.136",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",
@@ -21,6 +21,7 @@
     "node": ">=22.19.0 <25"
   },
   "scripts": {
+    "postinstall": "node bin/sync-pi-tui-proxy.js",
     "clean": "node scripts/clean.mjs",
     "build": "npm run clean && tsc -p tsconfig.build.json && node scripts/development/build-process-guardian.mjs",
     "build:process-guardian": "node scripts/development/build-process-guardian.mjs",