@botiverse/k-carrier 0.1.8 → 0.2.0

package/harness/src/artifact/m3.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import * as path from "node:path";
 import { type ToothContext } from "../teeth/registry.ts";
-import { PLAIN_DAEMON_SOURCE } from "../../../examples/service-daemon/source.ts";
+import { PLAIN_DAEMON_SOURCE } from "../fixtures/serviceSource.ts";
 import { serveRelease } from "./m1.ts";
 import { runCommand } from "../artifact-factory/run.ts";
 import { processAlive } from "../fake-host/daemon.ts";
@@ -10,7 +10,6 @@ import {
   serviceEnv,
   readIncarnation,
   killIncarnation,
-  respawnUntilUp,
   seedService,
   waitDead,
   HOST_SHAPES,
@@ -19,7 +18,7 @@ import {
 import { readState } from "./m1.ts";
 
 // ---------------------------------------------------------------------------
-// m3.service-upgrade (both host shapes)
+// m3.service-upgrade (external driver)
 // ---------------------------------------------------------------------------
 
 export async function checkM3ServiceUpgrade(
@@ -52,7 +51,6 @@ async function runUpgradeShape(
   });
   const { seedChild, seedPid } = await seedService(shapeCtx, shape, binPath, seed);
   const env = serviceEnv(shapeCtx, shape, target.url);
-  let respawned: Awaited<ReturnType<typeof respawnUntilUp>> | null = null;
   try {
     const before = await readIncarnation(shapeCtx);
     assert.ok(before, "a running incarnation must exist before the upgrade");
@@ -66,12 +64,6 @@ async function runUpgradeShape(
       0,
       `self upgrade must exit 0 (${up.stderr.trim()}; serveBadVersion mutation => RED)`,
     );
-    if (shape === "respawn") {
-      // Tracked, not discarded: if an assertion below fails, an untracked
-      // live service keeps the test runner alive and a red degrades into a
-      // hang -- the failure mode is then indistinguishable from a wedge.
-      respawned = await respawnUntilUp(shapeCtx, env);
-    }
 
     // signal-sent ≠ dead: the OLD pid must be VERIFIED gone.
     assert.ok(!processAlive(oldPid), `[${shape}] the old incarnation must be verified dead`);
@@ -91,9 +83,6 @@ async function runUpgradeShape(
     assert.equal(state.stableVersion, "2.0.0", `[${shape}] stable slot must hold the new version`);
     assert.equal(state.phase, "promoted", `[${shape}] journal must end at promoted`);
   } finally {
-    if (respawned && respawned.child.pid && processAlive(respawned.child.pid)) {
-      respawned.child.kill("SIGKILL");
-    }
     await killIncarnation(shapeCtx);
     if (processAlive(seedPid)) seedChild.kill("SIGKILL");
     await seed.stop();
@@ -102,7 +91,7 @@ async function runUpgradeShape(
 }
 
 // ---------------------------------------------------------------------------
-// m3.service-rollback (both host shapes)
+// m3.service-rollback (external driver)
 // ---------------------------------------------------------------------------
 
 export async function checkM3ServiceRollback(
@@ -135,19 +124,12 @@ async function runRollbackShape(
   });
   const { seedChild, seedPid } = await seedService(shapeCtx, shape, binPath, seed);
   const env = serviceEnv(shapeCtx, shape, target.url);
-  let respawned: Awaited<ReturnType<typeof respawnUntilUp>> | null = null;
   try {
     const before = await readIncarnation(shapeCtx);
     assert.ok(before, "a running incarnation must exist before the upgrade");
     const oldPid = before!.pid;
 
     const up = await runCommand(binPath, ["self", "upgrade"], { env, timeoutMs: 30000 });
-    if (shape === "respawn") {
-      // Tracked, not discarded: if an assertion below fails, an untracked
-      // live service keeps the test runner alive and a red degrades into a
-      // hang -- the failure mode is then indistinguishable from a wedge.
-      respawned = await respawnUntilUp(shapeCtx, env);
-    }
 
     const state = await readState(env);
     if (serveGoodVersion) {
@@ -168,8 +150,6 @@ async function runRollbackShape(
         `[${shape}] upgrade to a bad version must exit non-zero (${up.stderr.trim()})`,
       );
     }
-    // (the respawn-shape driver exits 0 to request the successor; the
-    // outcome is decided by the successor's recovery below)
     assert.equal(state.phase, "rolled-back", `[${shape}] journal must end at rolled-back`);
     assert.equal(state.stableVersion, "1.0.0", `[${shape}] stable slot must hold the old version`);
     assert.equal(state.experimentVersion, null, `[${shape}] experiment slot must be cleared`);
@@ -187,9 +167,6 @@ async function runRollbackShape(
     );
     assert.ok(!processAlive(oldPid), `[${shape}] the pre-upgrade incarnation must stay dead`);
   } finally {
-    if (respawned && respawned.child.pid && processAlive(respawned.child.pid)) {
-      respawned.child.kill("SIGKILL");
-    }
     await killIncarnation(shapeCtx);
     if (processAlive(seedPid)) seedChild.kill("SIGKILL");
     await seed.stop();
@@ -198,98 +175,42 @@ async function runRollbackShape(
 }
 
 // ---------------------------------------------------------------------------
-// m3.stuck-driver-evidence-recovery (respawn shape)
+// m3.stuck-driver-rollback-recovery
 // ---------------------------------------------------------------------------
 
-/**
- * A wedged driver (host.stop() never returns) must not wedge the updater:
- * the host-call budget times the driver out, the upgrade lock is released,
- * the owner respawns the successor, and the successor's recovery decides by
- * EVIDENCE (a live v2 with a fresh startId) — never by a "this restart was
- * planned" flag. `skipRecovery` simulates the must-red mutation (the
- * successor never recovers, so the transaction stays pending).
- */
+/** A fresh external driver must undo interrupted work, never adopt a candidate. */
 export async function checkM3StuckDriverEvidence(
   ctx: ToothContext,
   opts: { skipRecovery?: boolean } = {},
 ): Promise<void> {
-  const shape: HostShape = "respawn";
+  const shape: HostShape = "spawn";
   const shapeCtx: ToothContext = { profile: ctx.profile, sandboxDir: path.join(ctx.sandboxDir, shape) };
   const binPath = await buildServiceDaemon(shapeCtx);
-  const seed = await serveRelease(shapeCtx, {
-    version: "1.0.0",
-    behavior: "ok",
-    name: "seed",
-    source: PLAIN_DAEMON_SOURCE,
-  });
-  const target = await serveRelease(shapeCtx, {
-    version: "2.0.0",
-    behavior: "ok",
-    name: "target",
-    source: PLAIN_DAEMON_SOURCE,
-  });
-  const { seedChild, seedPid } = await seedService(shapeCtx, shape, binPath, seed);
-  const env = serviceEnv(shapeCtx, shape, target.url);
-  let oldPid: number | null = null;
+  const seed = await serveRelease(shapeCtx, { version: "1.0.0", behavior: "ok", name: "seed", source: PLAIN_DAEMON_SOURCE });
+  const target = await serveRelease(shapeCtx, { version: "2.0.0", behavior: "ok", name: "target", source: PLAIN_DAEMON_SOURCE });
+  let seedPid: number | undefined;
   try {
-    const before = await readIncarnation(shapeCtx);
-    assert.ok(before, "a running incarnation must exist before the upgrade");
-    oldPid = before!.pid;
-
-    // The driver is wedged at stop(): it must time out (host-call budget),
-    // release the lock, and exit — never wedge the tooth.
-    const stuckEnv = { ...env, K_STUCK_DRIVER: "1" };
+    const seeded = await seedService(shapeCtx, shape, binPath, seed);
+    seedPid = seeded.seedPid;
+    const env = serviceEnv(shapeCtx, shape, target.url);
     const up = await runCommand(binPath, ["self", "upgrade"], {
-      env: stuckEnv,
-      timeoutMs: 30000,
+      env: { ...env, K_STUCK_DRIVER: "1" }, timeoutMs: 30000,
     });
-    assert.notEqual(up.code, 0, "the wedged driver must fail (budget timeout), not hang");
-
-    // The owner respawns the successor from the new bytes; its recovery
-    // acquires the (released) lock and decides by evidence.
-    const respawnEnv = { ...env, ...(opts.skipRecovery === true ? { K_SKIP_RECOVERY: "1" } : {}) };
-    const { info: successor, child } = await respawnUntilUp(shapeCtx, respawnEnv);
-    try {
-      if (opts.skipRecovery) {
-        // mutation: the successor never recovers — the transaction stays
-        // pending at handing-over, so the promoted assertion goes RED
-        const st = await readState(env);
-        assert.equal(st.phase, "promoted", "the successor's recovery must finish the transaction (skipRecovery => RED)");
-        return;
-      }
-
-      // ② the successor is up (respawned from the experiment bytes)
-      assert.equal(successor.version, "2.0.0", "the successor must run the new version");
-      assert.ok(processAlive(successor.pid), "the successor must be alive");
-      assert.notEqual(successor.startId, before!.startId, "the successor is a fresh incarnation");
-
-      // ③ the recovery's judgment matched the evidence (v2 + fresh startId):
-      // the transaction reached promoted, so the lock WAS released (the
-      // recovery acquired it) and the evidence said handover succeeded.
-      const state = await readState(env);
-      assert.equal(state.phase, "promoted", "recovery must finish at promoted (evidence, not a flag)");
-      assert.equal(state.stableVersion, "2.0.0", "stable must hold the new version");
-    } finally {
-      if (processAlive(successor.pid)) {
-        try {
-          process.kill(successor.pid, "SIGKILL");
-        } catch {
-          // already gone
-        }
-        await waitDead(successor.pid, 5000);
-      }
-      void child;
+    assert.notEqual(up.code, 0, "the wedged driver must fail");
+    if (!opts.skipRecovery) {
+      const recovery = await runCommand(binPath, ["self", "recover"], { env, timeoutMs: 30000 });
+      assert.equal(recovery.code, 0, `external recovery must complete: ${recovery.stderr}`);
     }
+    const state = await readState(env);
+    assert.equal(state.phase, "rolled-back", "external recovery must finish the transaction by rollback");
+    assert.equal(state.stableVersion, "1.0.0");
+    assert.equal(state.experimentVersion, null);
+    const running = await readIncarnation(shapeCtx);
+    assert.ok(running && processAlive(running.pid), "restored stable must be alive");
+    assert.equal(running.version, "1.0.0");
   } finally {
     await killIncarnation(shapeCtx);
-    if (oldPid !== null && processAlive(oldPid)) {
-      try {
-        process.kill(oldPid, "SIGKILL"); // the wedged stop never killed it
-      } catch {
-        // already gone
-      }
-    }
-    if (processAlive(seedPid)) seedChild.kill("SIGKILL");
+    if (seedPid && processAlive(seedPid)) { process.kill(seedPid, "SIGKILL"); await waitDead(seedPid, 5000); }
     await seed.stop();
     await target.stop();
   }

package/harness/src/artifact/m3Hosts.ts

@@ -9,25 +9,12 @@ import { FakeServer } from "../fake-server/server.ts";
 import { ArtifactFactory } from "../artifact-factory/factory.ts";
 import { processAlive } from "../fake-host/daemon.ts";
 import { commandForArtifact, runCommand } from "../artifact-factory/run.ts";
-import { PLAIN_DAEMON_SOURCE } from "../../../examples/service-daemon/source.ts";
-import { coreUpgraderUrl, readState } from "./m1.ts";
+import { PLAIN_DAEMON_SOURCE } from "../fixtures/serviceSource.ts";
+import { runnerFactoryUrl, readState } from "./m1.ts";
 
-/**
- * M3 host orchestration helpers — shared by both service-profile teeth
- * (m3.service-upgrade / m3.service-rollback), each of which runs on BOTH
- * host shapes:
- *  - spawn:   self-starting — the driver spawns the successor and finishes
- *             the transaction itself.
- *  - respawn: computer's shape — the driver DIES mid-handover (it cannot
- *             start itself; the owner respawns it from the new bytes), and
- *             the SUCCESSOR finishes the transaction via recovery, proving
- *             the handover by a fresh startId (a flag could be set by the
- *             crash path; a different incarnation is something that
- *             happened).
- */
-
-export type HostShape = "spawn" | "respawn";
-export const HOST_SHAPES: HostShape[] = ["spawn", "respawn"];
+/** External service driver; the resident never owns recovery. */
+export type HostShape = "spawn";
+export const HOST_SHAPES: HostShape[] = ["spawn"];
 
 const INCARNATION_FILE = "incarnation.json";
 
@@ -62,20 +49,19 @@ function stateDir(ctx: ToothContext): string {
 
 export function serviceEnv(
   ctx: ToothContext,
-  shape: HostShape,
+  _shape: HostShape,
   baseUrl: string,
 ): Record<string, string> {
   return {
     K_RELEASE_BASE: baseUrl,
     K_STATE_DIR: stateDir(ctx),
-    K_HOST_SHAPE: shape,
-    K_CORE_UPGRADER: coreUpgraderUrl(),
+    K_CORE_UPGRADER: runnerFactoryUrl(),
     // Every process this tooth spawns — and, via inheritance, every process
     // the driver spawns — carries the sandbox marker, so the sandbox
     // teardown's verifyProcessTreeDead is the backstop for any leak: a "red"
     // can never degrade into a hang.
     // Resolved back to the SANDBOX id: ctx here is a per-shape NESTED context,
-    // and basename() of that is "spawn"/"respawn" -- a marker no teardown scan
+    // and basename() of that is "spawn" -- a marker no teardown scan
     // matches, which turns the backstop into a scan that always finds zero.
     K_SANDBOX_MARKER: sandboxMarkerFor(ctx.sandboxDir),
   };
@@ -178,42 +164,7 @@ export async function killIncarnation(ctx: ToothContext): Promise<void> {
   }
 }
 
-/**
- * The OWNER (respawn shape): the driver exits mid-handover; the owner
- * respawns the service from the new bytes (experiment first), falling back
- * to stable when the new version cannot start, and respawning again when a
- * recovery asks for a successor by exiting. A bounded loop: the service
- * eventually stays up or the owner gives up.
- */
-export async function respawnUntilUp(
-  ctx: ToothContext,
-  env: Record<string, string>,
-): Promise<{ info: Incarnation; child: ChildProcess }> {
-  const dir = stateDir(ctx);
-  for (let attempt = 0; attempt < 6; attempt++) {
-    const slot: "experiment" | "stable" = attempt === 0 ? "experiment" : "stable";
-    const artifact = path.join(dir, "slots", slot, "artifact.bin");
-    try {
-      await fs.access(artifact);
-    } catch {
-      continue;
-    }
-    const child = spawn(process.execPath, [artifact], {
-      env: { ...process.env, ...env },
-      stdio: ["pipe", "pipe", "ignore"],
-    });
-    const info = await tryReady(child, 2000);
-    if (info !== null) return { info, child };
-    if (child.pid && processAlive(child.pid)) child.kill("SIGKILL");
-  }
-  throw new Error("owner: the service never came up");
-}
-
-/**
- * Seed the service world: spawn the v1 service (registers), then a real
- * driver upgrade to 1.0.0 lands stable v1 with a running incarnation
- * (driver-completed on spawn, successor-completed on respawn).
- */
+/** Seed stable v1 with an external driver and a live service. */
 export async function seedService(
   ctx: ToothContext,
   shape: HostShape,
@@ -228,9 +179,6 @@ export async function seedService(
 
   const up = await runCommand(binPath, ["self", "upgrade"], { env, timeoutMs: 30000 });
   assert.equal(up.code, 0, `seed upgrade must exit 0 (${up.stderr.trim()})`);
-  if (shape === "respawn") {
-    await respawnUntilUp(ctx, env); // the driver died; the owner brings the successor up
-  }
   const seeded = await readState(env);
   assert.equal(seeded.stableVersion, "1.0.0", "seed upgrade must land stable 1.0.0");
   const running = await readIncarnation(ctx);

package/harness/src/artifact/m4.ts

@@ -16,8 +16,8 @@ import { promises as fs } from "node:fs";
 import { type ToothContext } from "../teeth/registry.ts";
 import { FakeServer } from "../fake-server/server.ts";
 import { runCommand } from "../artifact-factory/run.ts";
-import { buildSwapTool, coreUpgraderUrl, readState, serveRelease } from "./m1.ts";
-import { CLI_TOOL_SOURCE } from "../../../examples/swap-tool/source.ts";
+import { buildSwapTool, runnerFactoryUrl, readState, serveRelease } from "./m1.ts";
+import { CLI_TOOL_SOURCE } from "../fixtures/cliToolSource.ts";
 import { ArtifactFactory } from "../artifact-factory/factory.ts";
 import { currentPlatformKey } from "../../../core/src/artifact/staticManifestSource.ts";
 
@@ -25,7 +25,7 @@ function swapEnv(ctx: ToothContext, baseUrl: string, servers: FakeServer[], extr
   return {
     K_RELEASE_BASE: baseUrl,
     K_STATE_DIR: path.join(ctx.sandboxDir, "state"),
-    K_CORE_UPGRADER: coreUpgraderUrl(),
+    K_CORE_UPGRADER: runnerFactoryUrl(),
     ...extra,
   };
 }

package/harness/src/artifact/m5.ts

@@ -3,14 +3,14 @@
  * (test-plan M5 rows: 点名面读回一致；面在 allowlist 才可作证；未注册面被引用
  * ⇒ 拒; fail-closed 退役序; 禁投影).
  *
- * These drive createUpgrader in-process (the library plane — the converge
+ * These drive createRunner in-process (the library plane — the converge
  * machinery is exactly the kind of internal tooth the black-box plane
  * cannot reach).
  */
 import assert from "node:assert/strict";
 import * as path from "node:path";
 import { type ToothContext } from "../teeth/registry.ts";
-import { createUpgrader, type CreateUpgraderOptions } from "../../../core/src/createUpgrader.ts";
+import { createRunner, type RunnerOptions } from "../../../core/src/createRunner.ts";
 import { staticManifestSource } from "../../../core/src/artifact/staticManifestSource.ts";
 import {
   buildSurfaceAllowlist,
@@ -66,8 +66,8 @@ function makeUpgrader(
   ctx: ToothContext,
   server: FakeServer,
   surfaces: ReadbackSurface[],
-): ReturnType<typeof createUpgrader> {
-  const opts: CreateUpgraderOptions = {
+): ReturnType<typeof createRunner> {
+  const opts: RunnerOptions = {
     host: simpleHost(),
     source: staticManifestSource({ baseUrl: server.url }),
     policy: "auto",
@@ -75,7 +75,7 @@ function makeUpgrader(
     stateDir: stateDir(ctx),
     lifecycleSurfaces: surfaces,
   };
-  return createUpgrader(opts);
+  return createRunner(opts);
 }
 
 // ---------------------------------------------------------------------------

package/harness/src/artifact/m6.ts

@@ -5,7 +5,7 @@
  * genesis; every reconcile that reaches the transaction records WHO drove
  * it, write-ahead).
  *
- * These drive createUpgrader in-process (the library plane — the journal
+ * These drive createRunner in-process (the library plane — the journal
  * is exactly the kind of internal tooth the black-box plane cannot reach).
  * Mutation journals/summaries live in m6Mutations.ts (line budget).
  */
@@ -13,7 +13,7 @@ import assert from "node:assert/strict";
 import * as path from "node:path";
 import { promises as fs } from "node:fs";
 import { type ToothContext } from "../teeth/registry.ts";
-import { createUpgrader, type CreateUpgraderOptions } from "../../../core/src/createUpgrader.ts";
+import { createRunner, type RunnerOptions } from "../../../core/src/createRunner.ts";
 import type { ReleaseSource } from "../../../core/src/artifact/source.ts";
 import { staticManifestSource } from "../../../core/src/artifact/staticManifestSource.ts";
 import {
@@ -75,16 +75,16 @@ export async function makeUpgrader(
   server: FakeServer,
   journal: ProvenanceJournal | null,
   opts: MakeUpgraderOpts = {},
-): Promise<ReturnType<typeof createUpgrader>> {
-  const base: Omit<CreateUpgraderOptions, "provenance"> = {
+): Promise<ReturnType<typeof createRunner>> {
+  const base: Omit<RunnerOptions, "provenance"> = {
     host: opts.host ?? hostReporting("2.0.0"),
     source: opts.source ?? staticManifestSource({ baseUrl: server.url }),
     policy: opts.policy ?? "auto",
-    notificationSink: (opts.notificationSink ?? (async () => {})) as CreateUpgraderOptions["notificationSink"],
+    notificationSink: (opts.notificationSink ?? (async () => {})) as RunnerOptions["notificationSink"],
     stateDir: stateDir(ctx),
     ...(opts.installOwnership === undefined ? {} : { installOwnership: opts.installOwnership }),
   };
-  return createUpgrader(journal === null ? base : { ...base, provenance: journal });
+  return createRunner(journal === null ? base : { ...base, provenance: journal });
 }
 
 // ---------------------------------------------------------------------------

package/harness/src/artifact/m6Status.ts

@@ -5,7 +5,7 @@
  * an unreadable report is its own state, never "never observed"; an
  * observed pass survives a restart).
  *
- * These drive createUpgrader in-process: status() is the L5 read-back
+ * These drive createRunner in-process: status() is the L5 read-back
  * surface, and the teeth pin that it is a READ-BACK, not an invention.
  */
 import assert from "node:assert/strict";

package/harness/src/examples/checks.ts

@@ -2,9 +2,7 @@
  * Examples acceptance checks — the run bodies of the demo teeth
  * (registered in teeth/examples.ts). Each throws on violation.
  *
- * Each demo is the credential for its profile's support claim
- * (examples/README.md: "if a profile has no green example, the claim does
- * not exist"):
+ * These fixtures exercise internal mechanisms, not application integration:
  *  - swap-tool: black-box upgrade loop (L0/L0.5/L1') — version command,
  *    self-upgrade swaps bytes, next run reports the served version;
  *  - service-daemon: process-reality L2/L3 — real spawn, startId-bound
@@ -31,12 +29,12 @@ import {
   checkProbeBindsCurrentIncarnation,
 } from "../fake-host/checks.ts";
 import type { HostDriver } from "../fake-host/inproc.ts";
-import { CLI_TOOL_SOURCE } from "../../../examples/swap-tool/source.ts";
-import { PLAIN_DAEMON_SOURCE } from "../../../examples/service-daemon/source.ts";
+import { CLI_TOOL_SOURCE } from "../fixtures/cliToolSource.ts";
+import { PLAIN_DAEMON_SOURCE } from "../fixtures/serviceSource.ts";
 
 const RELEASE_BASE_ENV = "K_RELEASE_BASE";
 
-/** The swap-tool's explicit target declaration (mirrors k.target.ts). */
+/** The swap-tool fixture's explicit black-box target declaration. */
 export const CLI_TOOL_TARGET_TS = `export default { version: ["--version"], selfUpgrade: ["self", "upgrade"] };
 `;
 
@@ -71,9 +69,9 @@ async function fileSha256(p: string): Promise<string> {
   return sha256Hex(new Uint8Array(await fs.readFile(p)));
 }
 
-/** The swap-tool demo's @botiverse/k-carrier wiring (createUpgrader module URL). */
-function coreUpgraderUrl(): string {
-  return pathToFileURL(path.join(import.meta.dirname, "../../../core/src/createUpgrader.ts")).href;
+/** The swap-tool demo's @botiverse/k-carrier wiring (createRunner module URL). */
+function runnerFactoryUrl(): string {
+  return pathToFileURL(path.join(import.meta.dirname, "../../../core/src/createRunner.ts")).href;
 }
 
 // ---------------------------------------------------------------------------
@@ -111,7 +109,7 @@ export async function checkCliToolBlackbox(
     const up = await runCommand(binPath, ["self", "upgrade"], {
       env: {
         [RELEASE_BASE_ENV]: server.url,
-        K_CORE_UPGRADER: coreUpgraderUrl(),
+        K_CORE_UPGRADER: runnerFactoryUrl(),
       },
     });
     assert.equal(up.code, 0, `self upgrade must exit 0 (${up.stderr.trim()})`);
@@ -237,9 +235,8 @@ export async function checkPlainDaemonContract(
     const up = await runCommand(binPath, ["self", "upgrade"], {
       env: {
         [RELEASE_BASE_ENV]: server.url,
-        K_CORE_UPGRADER: coreUpgraderUrl(),
+        K_CORE_UPGRADER: runnerFactoryUrl(),
         K_STATE_DIR: stateDir,
-        K_HOST_SHAPE: "spawn",
       },
       timeoutMs: 30000,
     });
@@ -275,7 +272,7 @@ export async function checkManagedHostAdapter(
   const makeHost = async (): Promise<HostDriver> =>
     opts.hostOverride
       ? opts.hostOverride()
-      : (await import("../../../examples/hosted-service/host.ts")).createManagedHost(
+      : (await import("../fixtures/managedHost.ts")).createManagedHost(
           path.join(ctx.sandboxDir, "host"),
         );
   // the same contract subset k-harness --adapter runs (§1.7)