@fitchmultz/pi-subagents 0.50.0 → 0.51.0

package/scripts/native-package-smoke.mjs

@@ -1,5 +1,7 @@
 // Runtime-only package probe: selected native SDK/CLI, real packed actor and private broker.
 import assert from "node:assert/strict";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
 import {
   mkdtempSync,
   mkdirSync,
@@ -10,13 +12,15 @@ import {
   existsSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { hostCli, hostIndex, hostRoot } from "./compat-host.mjs";
 import { SmokeProcesses } from "./real-pi-processes.mjs";
 
+const execFile = promisify(execFileCallback);
+
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
   console.log(
     "Usage: node scripts/native-package-smoke.mjs [package-root]\n\nLoad the single compiled entry using the selected native host. Exercise all three eager package tools and a real actor prompt/toolResult/completion with a credential-free provider, then verify bundled CLI startup and shutdown. No paid model calls.\nExit codes: 0 passed; 1 native execution or cleanup failed.",
@@ -25,6 +29,8 @@ if (process.argv.includes("--help") || process.argv.includes("-h")) {
 }
 
 const packageRoot = realpathSync(resolve(process.argv[2] ?? "."));
+const consumerDir = process.argv[3];
+const consumerScript = process.argv[4];
 const root = mkdtempSync(join(tmpdir(), "ps-native-"));
 const agentDir = join(root, "agent");
 mkdirSync(join(agentDir, "extensions"), { recursive: true });
@@ -105,16 +111,24 @@ export default function(pi) {
         assert.deepEqual([...tools].sort(), ${JSON.stringify(expectedTools)});
       }
       observe({ tools, requested: true });
-      return fauxAssistantMessage(fauxToolCall(child ? "packed_probe" : "delegate", child ? { value: "native-tool-input" } : { prompt: ${JSON.stringify(prompt)}, name: "packed-native", async: false }), { stopReason: "toolUse" });
+      return fauxAssistantMessage(fauxToolCall(child ? "packed_probe" : "delegate", child ? { value: "native-tool-input" } : { prompt: ${JSON.stringify(prompt)}, name: "packed-native" }), { stopReason: "toolUse" });
     },
     (context) => {
       const result = context.messages.findLast(message => message.role === "toolResult");
       assert.equal(result?.isError ?? false, false);
       assert.equal(result?.toolName, child ? "packed_probe" : "delegate");
-      assert.ok(result.content.some(part => part.type === "text" && part.text.includes(child ? "PACKED_TOOL_RESULT" : "PACKED_NATIVE_COMPLETE")));
+      // The parent gets only an honest launch receipt; the child's outcome arrives later.
+      assert.ok(result.content.some(part => part.type === "text" && (child ? part.text.includes("PACKED_TOOL_RESULT") : part.text.includes("Launch accepted") && !part.text.includes("PACKED_NATIVE_COMPLETE"))));
       observe({ consumedResult: true, calls: faux.state.callCount });
-      return fauxAssistantMessage(child ? "PACKED_NATIVE_COMPLETE" : "PACKED_PARENT_COMPLETE");
-    }
+      return fauxAssistantMessage(child ? "PACKED_NATIVE_COMPLETE" : "PACKED_LAUNCH_RECEIPT_SEEN");
+    },
+    ...(child ? [] : [(context) => {
+      const notice = context.messages.at(-1);
+      const text = typeof notice.content === "string" ? notice.content : notice.content.map(part => part.text ?? "").join("");
+      assert.ok(text.includes(": completed. \\nPACKED_NATIVE_COMPLETE\\n"), text);
+      observe({ consumedCompletion: true, calls: faux.state.callCount });
+      return fauxAssistantMessage("PACKED_PARENT_COMPLETE");
+    }])
   ]);
   pi.registerProvider(faux.provider);
 }
@@ -141,6 +155,7 @@ const processes = new SmokeProcesses({
 let session;
 let watchdog;
 let brokerError;
+let intercomEvents;
 const brokerRun = processes
   .run("private broker", process.execPath, [join(packageRoot, "dist/pi-intercom/broker/broker.js")])
   .catch((error) => {
@@ -166,14 +181,21 @@ try {
     noContextFiles: true,
     noPromptTemplates: true,
     noThemes: true,
+    extensionFactories: consumerScript
+      ? [
+          (pi) => {
+            intercomEvents = pi.events;
+          },
+        ]
+      : [],
   });
   await loader.reload();
   assert.deepEqual(loader.getExtensions().errors, []);
   assert.deepEqual(loader.getExtensions().warnings ?? [], []);
   assert.equal(
     loader.getExtensions().extensions.length,
-    2,
-    "one package entry plus credential-free provider fixture",
+    consumerScript ? 3 : 2,
+    "one package entry plus credential-free provider and optional client observer fixtures",
   );
   const modelRuntime = await sdk.ModelRuntime.create({
     credentials: new ai.InMemoryCredentialStore(),
@@ -218,6 +240,29 @@ try {
   }, 30_000);
   await session.prompt("Exercise the packed native delegate.", { expandPromptTemplates: false });
   await session.waitForIdle();
+  assert.equal(
+    session.getLastAssistantText(),
+    "PACKED_LAUNCH_RECEIPT_SEEN",
+    JSON.stringify({
+      errors,
+      messages: events.filter(
+        (event) =>
+          (event.type === "message_end" && event.message?.role === "assistant") ||
+          event.type === "tool_execution_end",
+      ),
+    }),
+  );
+  const completionDeadline = Date.now() + 30_000;
+  while (session.getLastAssistantText() !== "PACKED_PARENT_COMPLETE") {
+    // Observe the native completion notification turn, not a fixed delay.
+    assert.ok(
+      Date.now() < completionDeadline,
+      `native completion notification resumes the parent: ${JSON.stringify(session.messages.slice(-3))}`,
+    );
+    // oxlint-disable-next-line no-await-in-loop
+    await delay(25);
+  }
+  await session.waitForIdle();
   clearTimeout(watchdog);
   assert.equal(
     session.getLastAssistantText(),
@@ -235,11 +280,13 @@ try {
     (event) => event.type === "tool_execution_start" && event.toolName === "delegate",
   );
   assert.equal(starts.length, 1, "one real native delegate call, no fabricated wire events");
-  const completion = events.find(
+  const receipt = events.find(
     (event) => event.type === "tool_execution_end" && event.toolName === "delegate",
   );
-  assert.ok(completion && !completion.isError, JSON.stringify(completion));
-  const run = completion.result.details;
+  assert.ok(receipt && !receipt.isError, JSON.stringify(receipt));
+  assert.equal(receipt.result.details.receipt, "launch");
+  const run = (await execute("agent_runs", { action: "inspect", id: receipt.result.details.id }))
+    .details;
   assert.equal(run.status, "completed");
   assert.equal(run.output.text, "PACKED_NATIVE_COMPLETE");
   const childEntries = readFileSync(run.sessionFile, "utf8")
@@ -280,6 +327,11 @@ try {
     observed.filter((item) => !item.child && item.consumedResult && item.calls === 2).length,
     1,
   );
+  assert.equal(
+    observed.filter((item) => !item.child && item.consumedCompletion && item.calls === 3).length,
+    1,
+    "the parent is resumed exactly once by the native completion notification",
+  );
   assert.equal(networkAttempts, 0);
   assert.equal(
     observed.some((item) => item.networkAttempt),
@@ -287,13 +339,102 @@ try {
   );
   assert.deepEqual(errors, []);
 
+  if (consumerScript) {
+    let target;
+    intercomEvents.emit("pi-intercom:context-query", {
+      version: 1,
+      respond: (snapshot) => {
+        target = snapshot;
+      },
+    });
+    assert.ok(target?.connected && target.peerId && target.rootSessionId && target.incarnation);
+    const guard = {
+      rootSessionId: target.rootSessionId,
+      peerId: target.peerId,
+      incarnation: target.incarnation,
+      applicationGuard: "package-consent-1",
+    };
+    let consent;
+    intercomEvents.emit("pi-intercom:application-guard", {
+      version: 1,
+      target: guard,
+      revision: guard.applicationGuard,
+      respond: (result) => {
+        consent = result;
+      },
+    });
+    assert.equal(consent.applicationGuard, guard.applicationGuard);
+    const consumerHome = join(root, "consumer-home");
+    mkdirSync(consumerHome);
+    const brokerPid = Number(
+      readFileSync(join(process.env.PI_INTERCOM_RUNTIME_DIR, "broker.pid"), "utf8").split("\n")[0],
+    );
+    const consumerOptions = {
+      cwd: consumerDir,
+      env: {
+        HOME: consumerHome,
+        PATH: process.env.PATH,
+        PI_CODING_AGENT_DIR: join(consumerHome, "agent"),
+        PI_INTERCOM_RUNTIME_DIR: process.env.PI_INTERCOM_RUNTIME_DIR,
+        S3_ROOT: guard.rootSessionId,
+        S3_PEER: guard.peerId,
+        S3_INCARNATION: guard.incarnation,
+        S3_GUARD: guard.applicationGuard,
+        S3_BROKER_PID: String(brokerPid),
+      },
+      timeout: 30_000,
+      maxBuffer: 1024 * 1024,
+    };
+    const turns = events.filter((event) => event.type === "turn_start").length;
+    try {
+      const { stdout, stderr } = await execFile(
+        process.execPath,
+        [
+          "--permission",
+          "--allow-fs-read=*",
+          "--allow-fs-write=*",
+          "--input-type=module",
+          "-e",
+          readFileSync(consumerScript, "utf8"),
+        ],
+        consumerOptions,
+      );
+      process.stdout.write(stdout);
+      process.stderr.write(stderr);
+      assert.equal(events.filter((event) => event.type === "turn_start").length, turns);
+    } finally {
+      // The consumer's failure/timeout must never leave this fixture's broker stopped.
+      process.kill(brokerPid, "SIGCONT");
+    }
+  }
+
   const marker = join(root, "cli.json");
   const observer = join(root, "observer.mjs");
   writeFileSync(
     observer,
-    `import { writeFileSync } from "node:fs"; export default function(pi) { pi.on("session_start", (_event, ctx) => { writeFileSync(${JSON.stringify(marker)}, JSON.stringify(pi.getActiveTools())); ctx.shutdown(); }); }`,
+    `import assert from "node:assert/strict";
+import { writeFileSync } from "node:fs";
+import { Type } from "typebox";
+import { Assert } from "typebox/value";
+import { Type as AgentType, Assert as AgentAssert } from ${JSON.stringify(pathToFileURL(join(packageRoot, "dist/agent/typebox.js")).href)};
+export default function(pi) {
+  // Native development graphs can resolve local peers before Jiti runs.
+  // Production-only installs must instead reuse the bundled host's virtual modules.
+  if (${!existsSync(join(packageRoot, "node_modules/typebox"))}) {
+    assert.equal(AgentType, Type, "extension schemas reuse Pi's TypeBox instance");
+    assert.equal(AgentAssert, Assert, "extension validation reuses Pi's TypeBox instance");
+  }
+  pi.on("session_start", (_event, ctx) => {
+    writeFileSync(${JSON.stringify(marker)}, JSON.stringify(pi.getActiveTools()));
+    ctx.shutdown();
+  });
+}`,
   );
-  const cliEnv = { ...process.env, PATH: "/usr/bin:/bin" };
+  const cliEnv = {
+    ...process.env,
+    PATH:
+      process.platform === "android" ? `${dirname(process.execPath)}:/system/bin` : "/usr/bin:/bin",
+  };
   delete cliEnv.PI_PACKAGE_DIR;
   const cliProcesses = new SmokeProcesses({
     cwd: root,

package/scripts/package-smoke.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
 import {
   cpSync,
   existsSync,
@@ -13,9 +12,10 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { hostRoot } from "./compat-host.mjs";
+import { compilerInvocation } from "./typescript.mjs";
 
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
   console.log(
@@ -95,12 +95,42 @@ function installProduction(pack) {
       );
     }
   }
-  return [installed, standalone];
+  return [
+    { packageRoot: installed, consumerDir: installDir },
+    { packageRoot: standalone, consumerDir: standalone },
+  ];
+}
+
+function verifyDeclarations(consumerDir) {
+  const contract = join(consumerDir, "public-client.test-d.ts");
+  cpSync(new URL("../test/fixtures/intercom-client-contract.test-d.ts", import.meta.url), contract);
+  const compiler = compilerInvocation();
+  run(
+    compiler.command,
+    [
+      ...compiler.args,
+      "--ignoreConfig",
+      "--noEmit",
+      "--strict",
+      "--target",
+      "ES2025",
+      "--module",
+      "NodeNext",
+      "--moduleResolution",
+      "NodeNext",
+      "--types",
+      "node",
+      "--typeRoots",
+      fileURLToPath(new URL("../node_modules/@types", import.meta.url)),
+      contract,
+    ],
+    consumerDir,
+  );
 }
 
-async function verifyRuntime(packageRoot) {
+async function verifyRuntime({ packageRoot, consumerDir }) {
   verifyManifest(JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")));
-  const hostRequire = createRequire(join(hostRoot, "dist/index.js"));
+  verifyDeclarations(consumerDir);
   const sdk = await import(pathToFileURL(join(hostRoot, "dist/index.js")).href);
   const nativeHost = await import(pathToFileURL(join(packageRoot, "dist/agent/host.js")).href);
   assert.equal(
@@ -108,11 +138,28 @@ async function verifyRuntime(packageRoot) {
     sdk,
     "actor must use the exact selected host SDK",
   );
-  const hostTypebox = await import(pathToFileURL(hostRequire.resolve("typebox")).href);
-  const nativeTypebox = await import(
-    pathToFileURL(join(packageRoot, "dist/agent/typebox.js")).href
+  run(
+    process.execPath,
+    [
+      "--input-type=module",
+      "-e",
+      `import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+const require = createRequire(${JSON.stringify(join(hostRoot, "dist/index.js"))});
+const hostTypebox = await import(pathToFileURL(require.resolve("typebox")).href);
+const hostValue = await import(pathToFileURL(require.resolve("typebox/value")).href);
+const native = await import(${JSON.stringify(pathToFileURL(join(packageRoot, "dist/agent/typebox.js")).href)});
+assert.equal(native.Type, hostTypebox.Type, "detached schemas use the selected host");
+assert.equal(native.Assert, hostValue.Assert, "detached validation uses the selected host");`,
+    ],
+    root,
+    {
+      ...process.env,
+      PI_INTERCOM_ROOT_SESSION_ID: "package-smoke",
+      PI_INTERCOM_PARENT_SESSION_ID: "package-smoke",
+    },
   );
-  assert.equal(nativeTypebox.Type, hostTypebox.Type, "shared schemas use the selected host");
   const broker = await import(
     pathToFileURL(join(packageRoot, "dist/pi-intercom/broker/spawn.js")).href
   );
@@ -123,12 +170,30 @@ async function verifyRuntime(packageRoot) {
     root,
   );
   assert.match(help, /Usage: node scripts\/intercom-bridge-credentials.mjs/);
+  const maintenanceHelp = run(
+    process.execPath,
+    [join(packageRoot, "scripts/archive-retired-history.mjs"), "--help"],
+    root,
+  );
+  assert.match(maintenanceHelp, /Offline-only opt-in maintenance/);
   process.stdout.write(
     run(
       process.execPath,
-      [fileURLToPath(new URL("./native-package-smoke.mjs", import.meta.url)), packageRoot],
+      [
+        fileURLToPath(new URL("./native-package-smoke.mjs", import.meta.url)),
+        packageRoot,
+        consumerDir,
+        fileURLToPath(new URL("../test/fixtures/intercom-client-consumer.mjs", import.meta.url)),
+      ],
       root,
-      { ...process.env, PI_PACKAGE_DIR: hostRoot, PATH: "/usr/bin:/bin" },
+      {
+        ...process.env,
+        PI_PACKAGE_DIR: hostRoot,
+        PATH:
+          process.platform === "android"
+            ? `${dirname(process.execPath)}:/system/bin`
+            : "/usr/bin:/bin",
+      },
     ),
   );
 }
@@ -146,6 +211,8 @@ try {
     "LICENSE",
     "README.md",
     "dist/index.js",
+    "dist/intercom-client.js",
+    "dist/intercom-client.d.ts",
     "dist/build-info.js",
     "dist/agent/runner.js",
     "dist/pi-intercom/broker/broker.js",
@@ -156,6 +223,8 @@ try {
     "scripts/build.mjs",
     "scripts/real-pi-smoke.mjs",
     "scripts/intercom-remote.mjs",
+    "scripts/archive-retired-history.mjs",
+    "docs/retired-history-maintenance.md",
     "skills/pi-subagents/SKILL.md",
     "skills/pi-intercom/SKILL.md",
   ]) {

package/scripts/prepare.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Purpose: Build generated dist output for GitHub/source installs even when Pi invokes npm install --omit=dev.
- * Responsibilities: Build with the local compiler when present; otherwise install only the pinned
+ * Responsibilities: Build with native Android tsgo or the local compiler; otherwise install only the pinned
  * `typescript` into a throwaway prefix, build with it, and delete the prefix. Emit needs no type
  * information (tsconfig.build.json sets noCheck), so the Pi host graph is never installed here.
  * Scope: Package install lifecycle only; runtime behavior remains owned by scripts/build.mjs.
@@ -46,7 +46,7 @@ async function runNode(args) {
 }
 
 async function main() {
-  if (existsSync(tscBin(cwd))) {
+  if (process.platform === "android" || existsSync(tscBin(cwd))) {
     await runNode([buildScript]);
     return;
   }