@llblab/pi-actors 0.31.0 → 0.33.0

package/lib/paths.ts

@@ -24,7 +24,7 @@ export interface ExtensionRuntimePaths {
 }
 
 export function getConfigPath(agentDir = getAgentDir()): string {
-  return join(agentDir, "legacy-tool-registry.json");
+  return join(agentDir, "tool-registry.json");
 }
 
 export function getExtensionTmpDir(
@@ -63,8 +63,8 @@ export function getRecipeRoot(agentDir = getAgentDir()): string {
   return join(agentDir, "recipes");
 }
 
-export function getRecipeCandidateRoot(agentDir = getAgentDir()): string {
-  return join(getRecipeRoot(agentDir), "candidates");
+export function getRecipeDraftRoot(agentDir = getAgentDir()): string {
+  return join(getRecipeRoot(agentDir), "drafts");
 }
 
 export function getPackagedRecipeRoot(): string {

package/lib/recipe-discovery.ts

@@ -461,16 +461,16 @@ function remediationForEntry(
   const riskyDiagnostics = entry.diagnostics.filter(
     (message) => diagnosticSeverity(message) === "warning",
   );
-  const blockedCandidate = entry.shadows[0];
+  const blockedFallback = entry.shadows[0];
   if (entry.invalid) {
     return {
       id: entry.id,
-      kind: blockedCandidate ? "blocking_invalid" : "invalid",
+      kind: blockedFallback ? "blocking_invalid" : "invalid",
       severity: "error",
       path: entry.path,
-      ...(blockedCandidate ? { blocked_candidate: blockedCandidate } : {}),
-      reason: blockedCandidate
-        ? "invalid higher-priority recipe blocks a lower-priority candidate"
+      ...(blockedFallback ? { blocked_fallback: blockedFallback } : {}),
+      reason: blockedFallback
+        ? "invalid higher-priority recipe blocks a lower-priority fallback"
         : "recipe is invalid and cannot be exposed as a tool",
       action:
         "fix recipe syntax/config, or disable/delete/archive it to restore fallback",
@@ -479,12 +479,12 @@ function remediationForEntry(
   if (entry.disabled && entry.active) {
     return {
       id: entry.id,
-      kind: blockedCandidate ? "blocking_disabled" : "disabled",
+      kind: blockedFallback ? "blocking_disabled" : "disabled",
       severity: "warning",
       path: entry.path,
-      ...(blockedCandidate ? { blocked_candidate: blockedCandidate } : {}),
-      reason: blockedCandidate
-        ? "disabled higher-priority recipe intentionally blocks a lower-priority candidate"
+      ...(blockedFallback ? { blocked_fallback: blockedFallback } : {}),
+      reason: blockedFallback
+        ? "disabled higher-priority recipe intentionally blocks a lower-priority fallback"
         : "recipe is disabled and not exposed as a tool",
       action:
         "keep disabled intentionally, re-enable, or delete/archive the file",
@@ -568,13 +568,13 @@ export function getShadowedLaunchDiagnostic(
   if (!active.invalid && !active.disabled) return undefined;
   return {
     active_path: active.path,
-    blocked_candidate: active.shadows[0],
+    blocked_fallback: active.shadows[0],
     hint: "inspect_recipes_doctor",
     reason: active.invalid ? "shadowed_invalid" : "shadowed_disabled",
   };
 }
 
-export function listCandidateRecipes(root: string): Array<Record<string, unknown>> {
+export function listDraftRecipes(root: string): Array<Record<string, unknown>> {
   return listRecipeFiles(root).map((path) => {
     const id = RecipeReferences.getRecipeIdFromPath(path);
     const config = RecipeReferences.readRawRecipeConfig(path);

package/lib/tools.ts

@@ -27,6 +27,12 @@ export type RegisterToolInput = Registry.RegisterToolInput;
 export type RegisterToolRuntimeDeps<TContext> =
   Registry.RegisterToolRuntimeDeps<TContext>;
 
+export interface ActorToolDefinition {
+  name: string;
+  execute?: (...args: never[]) => unknown;
+  [key: string]: unknown;
+}
+
 export interface CoreActorToolDefinitionDeps<TContext extends AsyncRunToolContext> {
   configPath: string;
   getActiveTools: () => string[];
@@ -222,8 +228,8 @@ function compactAsyncRunStatus(value: unknown): string {
     tokens.push(`failures=${failures}`);
   if (result.code !== undefined) tokens.push(`code=${String(result.code)}`);
   if (result.killed === true) tokens.push("killed=true");
-  if (status.candidate_recipe)
-    tokens.push(`candidate_recipe=${String(status.candidate_recipe)}`);
+  const draftRecipe = status.draft_recipe;
+  if (draftRecipe) tokens.push(`draft_recipe=${String(draftRecipe)}`);
   const nextActions = actorRunNextActions(run);
   if (nextActions.length > 0)
     tokens.push(`next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`);
@@ -451,6 +457,15 @@ function compactArtifactPath(value: unknown): string {
   return String(record.path ?? "<missing>");
 }
 
+function artifactNextActions(run: unknown, artifacts: Record<string, unknown>): string[] {
+  const id = String(run ?? "").trim();
+  if (!id || Object.keys(artifacts).length === 0) return [];
+  return [
+    `inspect target=run:${id} view=artifacts verbose=true`,
+    `inspect target=run:${id} view=messages`,
+  ];
+}
+
 function compactActorFiles(status: Record<string, unknown>): string {
   const run = String(status.run ?? "<unknown>");
   const artifacts = asRecord(status.artifacts);
@@ -469,7 +484,11 @@ function compactActorFiles(status: Record<string, unknown>): string {
         .map(([key, value]) => `${key}:${compactArtifactPath(value)}`)
         .join(",")}`
     : "";
-  return `\nrun=${run}${artifactText}${files.length ? ` files=${files.join(",")}` : ""}`;
+  const nextActions = artifactNextActions(run, artifacts);
+  const nextText = nextActions.length
+    ? ` next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`
+    : "";
+  return `\nrun=${run}${artifactText}${files.length ? ` files=${files.join(",")}` : ""}${nextText}`;
 }
 
 function summarizeOtherSessions(
@@ -614,16 +633,50 @@ function compactRecipeDoctor(summary: Record<string, unknown>): string {
       item.action,
       Limits.DOCTOR_ACTION_PREVIEW_CHARS,
     );
-    const blocked = item.blocked_candidate
-      ? ` blocked=${compactPreview(item.blocked_candidate, Limits.DOCTOR_ACTION_PREVIEW_CHARS)}`
+    const blocked = item.blocked_fallback
+      ? ` blocked=${compactPreview(item.blocked_fallback, Limits.DOCTOR_ACTION_PREVIEW_CHARS)}`
       : "";
     lines.push(
       `${String(item.severity ?? "info")} kind=${String(item.kind ?? "inspect")} id=${String(item.id ?? "root")}${blocked} action=${action ?? "inspect"}`,
     );
   }
+  const nextActions = Array.isArray(summary.next_actions)
+    ? (summary.next_actions as string[])
+    : [];
+  if (nextActions.length > 0) lines[0] = `${lines[0]}${compactNextActions(nextActions)}`;
   return `\n${lines.join("\n")}`;
 }
 
+function recipeRegistryNextActions(summary: Record<string, unknown>, view: string): string[] {
+  const actions: string[] = [];
+  const drafts = Array.isArray(summary.drafts)
+    ? (summary.drafts as Array<Record<string, unknown>>)
+    : [];
+  const invalid = Array.isArray(summary.invalid) ? summary.invalid.length : 0;
+  const diagnostics = Array.isArray(summary.diagnostics)
+    ? summary.diagnostics.length
+    : 0;
+  const topAction = asRecord(summary.top_action);
+  if (view !== "doctor" && (invalid > 0 || diagnostics > 0)) {
+    actions.push("inspect target=recipes view=doctor");
+  }
+  if (view === "doctor" && typeof topAction.action === "string") {
+    actions.push(String(topAction.action));
+  }
+  if (drafts.length > 0) {
+    actions.push("inspect target=recipes view=summary verbose=true");
+    const firstPath = typeof drafts[0]?.path === "string" ? drafts[0].path : undefined;
+    if (firstPath) actions.push(`spawn file=${firstPath}`);
+  }
+  return [...new Set(actions)].slice(0, 4);
+}
+
+function compactNextActions(actions: string[]): string {
+  return actions.length
+    ? ` next=${actions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`
+    : "";
+}
+
 function compactRecipeRegistry(summary: Record<string, unknown>): string {
   const active = Array.isArray(summary.active) ? summary.active.length : 0;
   const shadowed = Array.isArray(summary.shadowed)
@@ -636,13 +689,39 @@ function compactRecipeRegistry(summary: Record<string, unknown>): string {
   const diagnostics = Array.isArray(summary.diagnostics)
     ? summary.diagnostics.length
     : 0;
-  const candidates = Array.isArray(summary.candidates)
-    ? summary.candidates.length
-    : 0;
+  const drafts = Array.isArray(summary.drafts) ? summary.drafts.length : 0;
   const recommendations = Array.isArray(summary.recommendations)
     ? summary.recommendations.length
     : 0;
-  return `\nrecipes active=${active} candidates=${candidates} shadowed=${shadowed} invalid=${invalid} disabled=${disabled} recommendations=${recommendations} diagnostics=${diagnostics}`;
+  const nextActions = Array.isArray(summary.next_actions)
+    ? (summary.next_actions as string[])
+    : [];
+  return `\nrecipes active=${active} drafts=${drafts} shadowed=${shadowed} invalid=${invalid} disabled=${disabled} recommendations=${recommendations} diagnostics=${diagnostics}${compactNextActions(nextActions)}`;
+}
+
+function actorMessageNextActions(
+  message: ActorMessages.ActorMessage,
+  result: Record<string, unknown>,
+): string[] {
+  const actions: string[] = [];
+  const address = ActorMessages.parseActorAddress(message.to);
+  if (result.delivery_error || result.sent === false) {
+    if (address.kind === "run" && address.value) {
+      actions.push(`inspect target=run:${address.value} view=status`);
+      actions.push(`inspect target=run:${address.value} view=mailbox`);
+    } else if (address.kind === "branch" && address.value) {
+      actions.push(`inspect target=branch:${address.value}/${address.branch ?? "main"} view=mailbox`);
+      actions.push(`inspect target=run:${address.value} view=status`);
+    }
+  }
+  if (result.queued === true) {
+    if (address.kind === "branch" && address.value) {
+      actions.push(`inspect target=branch:${address.value}/${address.branch ?? "main"} view=mailbox`);
+    } else if (address.kind === "run" && address.value) {
+      actions.push(`inspect target=run:${address.value} view=mailbox`);
+    }
+  }
+  return [...new Set(actions)].slice(0, 3);
 }
 
 function compactActorMessageResult(
@@ -670,6 +749,11 @@ function compactActorMessageResult(
   if (result.delivery_error) {
     tokens.push(`delivery_error=${compactPreview(result.delivery_error, 96)}`);
   }
+  const nextActions = Array.isArray(result.next_actions)
+    ? (result.next_actions as string[])
+    : actorMessageNextActions(message, result);
+  if (nextActions.length > 0)
+    tokens.push(`next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`);
   return `\n${tokens.join(" ")}`;
 }
 
@@ -791,11 +875,11 @@ function shadowedRecipeLaunchDiagnostic(
   return RecipeDiscovery.getShadowedLaunchDiagnostic(discovery, recipe);
 }
 
-function candidateRecipeName(run: string): string {
+function draftRecipeName(run: string): string {
   return `${run.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "spawn"}.json`;
 }
 
-function candidateRecipeDefaults(
+function draftRecipeDefaults(
   values: Record<string, unknown>,
 ): Record<string, unknown> | undefined {
   const ignored = new Set([
@@ -811,13 +895,13 @@ function candidateRecipeDefaults(
   return Object.keys(defaults).length > 0 ? defaults : undefined;
 }
 
-function writeSpawnCandidateRecipe(
+function writeSpawnDraftRecipe(
   input: Record<string, unknown>,
   meta: AsyncRuns.AsyncRunMeta,
 ): string | undefined {
   if (
     process.env.NODE_TEST_CONTEXT &&
-    process.env.PI_ACTORS_ENABLE_SPAWN_CANDIDATES_IN_TEST !== "1"
+    process.env.PI_ACTORS_ENABLE_SPAWN_DRAFTS_IN_TEST !== "1"
   )
     return undefined;
   if (
@@ -826,13 +910,13 @@ function writeSpawnCandidateRecipe(
     input.recipe !== undefined
   )
     return undefined;
-  const root = Paths.getRecipeCandidateRoot();
+  const root = Paths.getRecipeDraftRoot();
   mkdirSync(root, { recursive: true });
-  const path = join(root, candidateRecipeName(String(meta.run)));
-  const defaults = candidateRecipeDefaults(meta.values);
+  const path = join(root, draftRecipeName(String(meta.run)));
+  const defaults = draftRecipeDefaults(meta.values);
   const recipe = {
     async: true,
-    description: `Candidate recipe captured from spawn run ${String(meta.run)}`,
+    description: `Draft recipe captured from spawn run ${String(meta.run)}`,
     ...(meta.artifacts ? { artifacts: meta.artifacts } : {}),
     ...(defaults ? { defaults } : {}),
     template: input.template,
@@ -848,7 +932,7 @@ function enhanceSpawnRecipeError(error: unknown, recipe: unknown): Error {
   const original = error instanceof Error ? error.message : String(error);
   return Object.assign(
     new Error(
-      `${original} reason=${diagnostic.reason} active_path=${diagnostic.active_path} blocked_candidate=${diagnostic.blocked_candidate} hint=${diagnostic.hint}`,
+      `${original} reason=${diagnostic.reason} active_path=${diagnostic.active_path} blocked_fallback=${diagnostic.blocked_fallback} hint=${diagnostic.hint}`,
     ),
     {
       ...diagnostic,
@@ -1036,11 +1120,11 @@ export function createSpawnToolDefinition<
       } catch (error) {
         throw enhanceSpawnRecipeError(error, recipe);
       }
-      const candidateRecipe = writeSpawnCandidateRecipe(input, meta);
+      const draftRecipe = writeSpawnDraftRecipe(input, meta);
       const nextActions = actorRunNextActions(meta.run);
       const details = {
         ...meta,
-        ...(candidateRecipe ? { candidate_recipe: candidateRecipe } : {}),
+        ...(draftRecipe ? { draft_recipe: draftRecipe } : {}),
         next_actions: nextActions,
       };
       ActorRooms.ensureDefaultRoom(meta.state_dir, String(meta.run));
@@ -1084,6 +1168,33 @@ function requireContextSessionId(ctx: unknown, actor: string): string {
   return sessionId;
 }
 
+function sessionMismatchError(input: {
+  currentSession?: string;
+  expectedSession?: string;
+  run?: string;
+  target?: string;
+}): Error {
+  const ownerSession = input.expectedSession ?? "none";
+  const currentSession = input.currentSession ?? "none";
+  const actor = input.run ? `run:${input.run}` : (input.target ?? "session");
+  const hintTarget = input.expectedSession
+    ? `session:${input.expectedSession}`
+    : "session:all";
+  return Object.assign(
+    new Error(
+      `${actor} reason=session_mismatch owner_session=${ownerSession} current_session=${currentSession} hint=inspect_session:${input.expectedSession ?? "all"}`,
+    ),
+    {
+      current_session: input.currentSession,
+      hint: `inspect target=${hintTarget} view=status`,
+      owner_session: input.expectedSession,
+      reason: "session_mismatch",
+      run: input.run,
+      target: input.target,
+    },
+  );
+}
+
 function assertRunAccessibleToContext(
   runId: string,
   ctx: unknown,
@@ -1091,18 +1202,11 @@ function assertRunAccessibleToContext(
   const status = AsyncRuns.getRunStatus(runId);
   const sessionId = getContextSessionId(ctx);
   if (sessionId && status.ownerId && status.ownerId !== sessionId) {
-    throw Object.assign(
-      new Error(
-        `run:${runId} reason=session_mismatch owner_session=${status.ownerId} current_session=${sessionId} hint=inspect_session:${status.ownerId}`,
-      ),
-      {
-        current_session: sessionId,
-        hint: `inspect target=session:${status.ownerId} view=status`,
-        owner_session: status.ownerId,
-        reason: "session_mismatch",
-        run: runId,
-      },
-    );
+    throw sessionMismatchError({
+      currentSession: sessionId,
+      expectedSession: String(status.ownerId),
+      run: runId,
+    });
   }
   return status;
 }
@@ -1120,7 +1224,7 @@ export function createInspectToolDefinition<TContext = unknown>(
     name: "inspect",
     label: "Inspect",
     description:
-      "Intentionally inspect an actor at decision points, after follow-ups, or during diagnosis instead of polling. Supports run:<id> views: status, tail, messages, artifacts, files, mailbox, communication; room:<run> status/messages/previews/roster/contacts; coordinator/session status; and tool:<name> status/schema.",
+      "Intentionally inspect actors at decision points, after follow-ups, or during diagnosis instead of polling. Core targets are run:<id> and tool:<name>; advanced targets include branch:<run>/<branch>, room:<run>, coordinator, session:<id>, and session:all.",
     parameters: objectSchema(
       {
         lines: stringSchema("Line count for tail/messages views. Default 40."),
@@ -1128,13 +1232,13 @@ export function createInspectToolDefinition<TContext = unknown>(
           "Optional session run filter: all, running, active, terminal, done, failed, cancelled, killed, or exited.",
         ),
         target: stringSchema(
-          "Actor address to inspect, e.g. run:<id>, room:<run>, coordinator, session:<id>, session:all, or tool:<name>.",
+          "Actor address to inspect, e.g. run:<id> or tool:<name>; advanced: branch:<run>/<branch>, room:<run>, coordinator, session:<id>, session:all.",
         ),
         verbose: booleanSchema(
           "Return full JSON instead of compact text where available.",
         ),
         view: stringSchema(
-          "Inspection view: status, tail, messages, artifacts, files, mailbox, communication, roster, or contacts.",
+          "Inspection view. Core run views: status, tail, messages, artifacts, files, mailbox. Advanced views include communication, roster, and contacts.",
         ),
       },
       ["target", "view"],
@@ -1169,11 +1273,13 @@ export function createInspectToolDefinition<TContext = unknown>(
           { root: deps.packagedRecipeRoot ?? Paths.getPackagedRecipeRoot() },
         ]);
         const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
-        const summary = {
+        const summaryBase = {
           ...RecipeDiscovery.summarizeDiscovery(discovered),
-          candidates: RecipeDiscovery.listCandidateRecipes(
-            join(recipeRoot, "candidates"),
-          ),
+          drafts: RecipeDiscovery.listDraftRecipes(join(recipeRoot, "drafts")),
+        };
+        const summary = {
+          ...summaryBase,
+          next_actions: recipeRegistryNextActions(summaryBase, view),
         };
         return {
           content: [
@@ -1488,7 +1594,14 @@ export function createInspectToolDefinition<TContext = unknown>(
               | undefined,
           );
           const details = artifactManifest
-            ? { ...status, artifact_manifest: artifactManifest }
+            ? {
+                ...status,
+                artifact_manifest: artifactManifest,
+                next_actions: artifactNextActions(
+                  status.run ?? runId,
+                  asRecord(status.artifacts),
+                ),
+              }
             : status;
           return {
             content: [
@@ -1574,7 +1687,7 @@ export function createActorMessageToolDefinition<TContext = unknown>(
     name: "message",
     label: "Message",
     description:
-      "Send one typed addressed message to steer an existing actor instead of restarting it. Routes to run:<id> mailboxes, branch:<run>/<branch> mailboxes, room:<run> timelines/rosters, tool:<name> calls, and coordinator/session-bound run messages.",
+      "Send one typed addressed message to steer an existing actor instead of restarting it. Core routes are run:<id> and tool:<name>; advanced routes include branch:<run>/<branch>, room:<run> group timelines, coordinator, and session:<id>.",
     parameters: objectSchema(
       {
         body: unionSchema([
@@ -1596,7 +1709,7 @@ export function createActorMessageToolDefinition<TContext = unknown>(
         reply_to: stringSchema("Optional message id this message replies to."),
         summary: stringSchema("Optional short human-facing summary."),
         to: stringSchema(
-          "Destination actor address, e.g. run:<id>, branch:<run>/<branch>, room:<run>, coordinator, session:<id>, or tool:<name>.",
+          "Destination actor address, e.g. run:<id> or tool:<name>; advanced: branch:<run>/<branch>, room:<run>, coordinator, session:<id>.",
         ),
         type: stringSchema(
           "Semantic message type, e.g. control.approve or checkpoint.needs_scope.",
@@ -1765,14 +1878,20 @@ export function createActorMessageToolDefinition<TContext = unknown>(
         const senderStatus = assertRunAccessibleToContext(sender.value, ctx);
         if (address.kind === "session") {
           if (!senderStatus.ownerId) {
-            throw new Error(
-              `message to session:${address.value} requires sender run owner ${address.value}; got no owner.`,
-            );
+            throw sessionMismatchError({
+              currentSession: undefined,
+              expectedSession: address.value,
+              run: sender.value,
+              target: `session:${address.value}`,
+            });
           }
           if (senderStatus.ownerId !== address.value) {
-            throw new Error(
-              `message to session:${address.value} requires sender run owner ${address.value}; got ${senderStatus.ownerId}.`,
-            );
+            throw sessionMismatchError({
+              currentSession: String(senderStatus.ownerId),
+              expectedSession: address.value,
+              run: sender.value,
+              target: `session:${address.value}`,
+            });
           }
         }
         result = AsyncRuns.appendRunOutboxEvent(sender.value, {
@@ -1796,18 +1915,22 @@ export function createActorMessageToolDefinition<TContext = unknown>(
           `message currently supports run:<id>, branch:<run>/<branch>, room:<run>, tool:<name>, coordinator, and session:<id> destinations; unsupported destination: ${message.to}`,
         );
       }
+      const nextActions = actorMessageNextActions(message, result);
+      const resultWithNext = nextActions.length
+        ? { ...result, next_actions: nextActions }
+        : result;
       return {
         content: [
           {
             type: "text" as const,
             text: maybeJsonText(
-              { message, result },
+              { message, result: resultWithNext },
               input.verbose === true,
-              compactActorMessageResult(message, result),
+              compactActorMessageResult(message, resultWithNext),
             ),
           },
         ],
-        details: { message, result },
+        details: { message, result: resultWithNext },
       };
     },
   };
@@ -1815,7 +1938,7 @@ export function createActorMessageToolDefinition<TContext = unknown>(
 
 export function createCoreActorToolDefinitions<TContext extends AsyncRunToolContext>(
   deps: CoreActorToolDefinitionDeps<TContext>,
-): any[] {
+): ActorToolDefinition[] {
   return [
     createRegisterToolDefinition<TContext>({
       configPath: deps.configPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [

package/scripts/conformance.mjs

@@ -1,33 +1,49 @@
 #!/usr/bin/env node
 
 /**
- * Internal conformance runner shim.
+ * Internal conformance runner.
  *
- * Runtime logic lives in lib/conformance.ts and is compiled to
- * dist/lib/conformance.js for installed JS-only packages.
+ * This script is intentionally standalone package/release glue rather than a
+ * lib domain: it only selects regression suites and formats their summary.
  */
 
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { spawnSync } from "node:child_process";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const conformanceSuites = [
+  "tests/protocol-examples.test.ts",
+  "tests/recipe-discovery.test.ts",
+  "tests/registry.test.ts",
+  "tests/runtime-registry.test.ts",
+  "tests/async-runs.test.ts",
+  "tests/actor-rooms.test.ts",
+  "tests/tools.test.ts",
+];
 
 function packageRoot() {
   return dirname(dirname(fileURLToPath(import.meta.url)));
 }
 
-function mainModulePath() {
-  const root = packageRoot();
-  const compiled = join(root, "dist", "lib", "conformance.js");
-  return existsSync(compiled) ? compiled : join(root, "lib", "conformance.ts");
-}
+const result = spawnSync(
+  process.execPath,
+  ["--experimental-strip-types", "--test", ...conformanceSuites],
+  { cwd: packageRoot(), encoding: "utf8", stdio: "pipe" },
+);
 
-const { runConformance } = await import(pathToFileURL(mainModulePath()).href);
-const report = runConformance(packageRoot());
+const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+const summary = output
+  .split("\n")
+  .filter((line) =>
+    /^ℹ (tests|pass|fail|cancelled|skipped|todo|duration_ms) /.test(line),
+  )
+  .join("\n");
 
 console.log("pi-actors conformance");
-console.log(`suites ${report.suites}`);
-if (report.summary) console.log(report.summary);
-if (report.code !== 0) {
-  console.error(report.output.trimEnd());
-  process.exit(report.code);
+console.log(`suites ${conformanceSuites.length}`);
+
+if (summary) console.log(summary);
+if ((result.status ?? 1) !== 0) {
+  console.error(output.trimEnd());
+  process.exit(result.status ?? 1);
 }