agenticros 0.1.17 → 0.1.19

package/runtime/packages/core/src/__tests__/find-robots-for.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Unit tests for Phase 1.e `findRobotsFor`.
+ *
+ * What these pin down (each test corresponds to a real failure mode in
+ * the multi-robot fleet UX):
+ *
+ *   - capability filter: matches against the global registry by default;
+ *     a per-robot allowlist OVERRIDES the global registry (heterogeneous
+ *     fleets); a capability absent from both filters the robot out.
+ *   - kind filter: case-insensitive, exact match, no fuzzy matching
+ *     (`amr` doesn't match `AMR Pro` — keeps the surface tiny).
+ *   - online filter: needs onlineIds; when true keeps only online; when
+ *     false keeps only offline; when omitted does not filter.
+ *   - ranking: explicit per-robot capability match outscores inherited;
+ *     online outscores offline; ties broken by config declaration order.
+ *   - error path: query.online set + no onlineIds throws so adapters
+ *     never silently skip the filter.
+ *   - back-compat: a config with no robots[] still works (the legacy
+ *     single robot is included with kind="amr" and all-false sensors).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseConfig } from "../config.js";
+import { findRobotsFor } from "../find-robots-for.js";
+
+function configWith(robots: unknown[]) {
+  return parseConfig({ robots });
+}
+
+test("findRobotsFor: no query → returns the whole fleet in config order", () => {
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+  ]);
+  const out = findRobotsFor(cfg, {});
+  assert.equal(out.total, 2);
+  assert.equal(out.robots[0].robot.id, "alpha");
+  assert.equal(out.robots[1].robot.id, "beta");
+});
+
+test("findRobotsFor: capability matches against the global registry by default", () => {
+  // `drive_base` is a built-in capability so both robots inherit it.
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+  ]);
+  const out = findRobotsFor(cfg, { capability: "drive_base" });
+  assert.equal(out.total, 2);
+  for (const m of out.robots) {
+    assert.equal(
+      m.matched_capability_explicitly,
+      false,
+      "no per-robot allowlist means the match is inherited",
+    );
+  }
+});
+
+test("findRobotsFor: capability absent from global registry filters everyone out", () => {
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+  ]);
+  const out = findRobotsFor(cfg, { capability: "no_such_capability" });
+  assert.equal(out.total, 0);
+});
+
+test("findRobotsFor: per-robot capability allowlist OVERRIDES the global registry", () => {
+  // beta declares an allowlist that includes `arm_grasp` only.
+  // alpha has no allowlist → falls back to the global registry which
+  // does NOT contain `arm_grasp` → alpha filtered out.
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    {
+      id: "beta",
+      namespace: "beta-ns",
+      capabilities: ["arm_grasp"],
+    },
+  ]);
+  const out = findRobotsFor(cfg, { capability: "arm_grasp" });
+  assert.equal(out.total, 1);
+  assert.equal(out.robots[0].robot.id, "beta");
+  assert.equal(out.robots[0].matched_capability_explicitly, true);
+});
+
+test("findRobotsFor: per-robot allowlist also filters out global capabilities NOT in the list", () => {
+  // beta's allowlist excludes `drive_base` — even though it's a builtin,
+  // beta declared a tighter set. So `drive_base` only matches alpha.
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    {
+      id: "beta",
+      namespace: "beta-ns",
+      capabilities: ["arm_grasp"],
+    },
+  ]);
+  const out = findRobotsFor(cfg, { capability: "drive_base" });
+  assert.equal(out.total, 1);
+  assert.equal(out.robots[0].robot.id, "alpha");
+});
+
+test("findRobotsFor: kind filter is case-insensitive and exact-match", () => {
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns", kind: "amr" },
+    { id: "beta", namespace: "beta-ns", kind: "arm" },
+    { id: "gamma", namespace: "gamma-ns", kind: "drone" },
+  ]);
+  const amrs = findRobotsFor(cfg, { kind: "AMR" });
+  assert.equal(amrs.total, 1);
+  assert.equal(amrs.robots[0].robot.id, "alpha");
+
+  const drones = findRobotsFor(cfg, { kind: "drone" });
+  assert.equal(drones.total, 1);
+  assert.equal(drones.robots[0].robot.id, "gamma");
+});
+
+test("findRobotsFor: kind filter rejects non-exact matches (no fuzzy)", () => {
+  const cfg = configWith([{ id: "alpha", namespace: "alpha-ns", kind: "amr-pro" }]);
+  // Looking for "amr" — "amr-pro" is NOT a match. Phase 1.e is exact.
+  assert.equal(findRobotsFor(cfg, { kind: "amr" }).total, 0);
+});
+
+test("findRobotsFor: online=true keeps only robots in the onlineIds set", () => {
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+    { id: "gamma", namespace: "gamma-ns" },
+  ]);
+  const onlineIds = new Set(["alpha", "gamma"]);
+  const out = findRobotsFor(cfg, { online: true }, onlineIds);
+  const ids = out.robots.map((m) => m.robot.id);
+  assert.deepEqual(ids, ["alpha", "gamma"]);
+  assert.equal(out.robots.every((m) => m.online === true), true);
+});
+
+test("findRobotsFor: online=false keeps only robots NOT in onlineIds", () => {
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+  ]);
+  const out = findRobotsFor(cfg, { online: false }, new Set(["alpha"]));
+  assert.equal(out.total, 1);
+  assert.equal(out.robots[0].robot.id, "beta");
+  assert.equal(out.robots[0].online, false);
+});
+
+test("findRobotsFor: providing onlineIds without query.online still annotates online status", () => {
+  // A common UX pattern: "show me everyone, but tell me which are online."
+  const cfg = configWith([
+    { id: "alpha", namespace: "alpha-ns" },
+    { id: "beta", namespace: "beta-ns" },
+  ]);
+  const out = findRobotsFor(cfg, {}, new Set(["alpha"]));
+  const alpha = out.robots.find((m) => m.robot.id === "alpha");
+  const beta = out.robots.find((m) => m.robot.id === "beta");
+  assert.equal(alpha?.online, true);
+  assert.equal(beta?.online, false);
+});
+
+test("findRobotsFor: online filter with no onlineIds throws (caller bug guard)", () => {
+  const cfg = configWith([{ id: "alpha", namespace: "alpha-ns" }]);
+  assert.throws(() => findRobotsFor(cfg, { online: true }), /onlineIds was not provided/);
+});
+
+test("findRobotsFor: ranking — explicit-allowlist match beats inherited match", () => {
+  const cfg = configWith([
+    { id: "inherited", namespace: "inh-ns" }, // inherits drive_base from registry
+    {
+      id: "explicit",
+      namespace: "exp-ns",
+      capabilities: ["drive_base"], // explicitly declares it
+    },
+  ]);
+  const out = findRobotsFor(cfg, { capability: "drive_base" });
+  assert.equal(out.total, 2);
+  assert.equal(
+    out.robots[0].robot.id,
+    "explicit",
+    "explicit allowlist match should rank above inherited",
+  );
+  assert.equal(out.robots[1].robot.id, "inherited");
+});
+
+test("findRobotsFor: ranking — online beats offline when query.online is true", () => {
+  const cfg = configWith([
+    { id: "offline", namespace: "off-ns" },
+    { id: "online", namespace: "on-ns" },
+  ]);
+  // We're not filtering by online (so both kept), but ranking should
+  // still surface the online one first.
+  const out = findRobotsFor(cfg, {}, new Set(["online"]));
+  assert.equal(out.robots[0].robot.id, "online");
+});
+
+test("findRobotsFor: ranking — ties broken by config declaration order (stable)", () => {
+  const cfg = configWith([
+    { id: "first", namespace: "first-ns" },
+    { id: "second", namespace: "second-ns" },
+    { id: "third", namespace: "third-ns" },
+  ]);
+  const out = findRobotsFor(cfg, {});
+  assert.deepEqual(
+    out.robots.map((m) => m.robot.id),
+    ["first", "second", "third"],
+  );
+});
+
+test("findRobotsFor: back-compat — empty robots[] still returns the legacy entry", () => {
+  // No robots[], just the legacy single-robot block. The resolver should
+  // synthesize one match with kind=amr and all-false sensors so that
+  // existing single-robot deployments work with `find_robots_for`.
+  const cfg = parseConfig({
+    robot: { name: "Legacy", namespace: "legacy-ns" },
+  });
+  const out = findRobotsFor(cfg, {});
+  assert.equal(out.total, 1);
+  assert.equal(out.robots[0].robot.id, "legacy-ns");
+  assert.equal(out.robots[0].robot.kind, "amr");
+  assert.equal(out.robots[0].robot.sensors.has_realsense, false);
+});
+
+test("findRobotsFor: combined filters — capability AND kind AND online", () => {
+  const cfg = configWith([
+    {
+      id: "amr-online",
+      namespace: "ao-ns",
+      kind: "amr",
+      capabilities: ["follow_person"],
+    },
+    {
+      id: "amr-offline",
+      namespace: "aoff-ns",
+      kind: "amr",
+      capabilities: ["follow_person"],
+    },
+    {
+      id: "arm-online",
+      namespace: "arm-ns",
+      kind: "arm",
+      capabilities: ["arm_grasp"],
+    },
+  ]);
+  const out = findRobotsFor(
+    cfg,
+    { capability: "follow_person", kind: "amr", online: true },
+    new Set(["amr-online", "arm-online"]),
+  );
+  assert.equal(out.total, 1);
+  assert.equal(out.robots[0].robot.id, "amr-online");
+});
+
+test("findRobotsFor: result.query echoes only the filters actually applied", () => {
+  const cfg = configWith([{ id: "alpha", namespace: "alpha-ns" }]);
+  const out = findRobotsFor(cfg, { kind: "AMR" });
+  assert.deepEqual(out.query, { kind: "amr" }, "kind is lowercased in the echo");
+  assert.equal("capability" in out.query, false, "absent fields aren't included");
+  assert.equal("online" in out.query, false);
+});

package/runtime/packages/core/src/__tests__/mission-cancel-transcript.test.ts

@@ -0,0 +1,371 @@
+/**
+ * Unit tests for Phase 1.f mission cancellation + transcripts.
+ *
+ * What these pin down (one test per behavioural contract the adapters
+ * and LLMs depend on):
+ *
+ *   Cancellation
+ *   ------------
+ *   - A token flipped BEFORE the first step cancels every step (no
+ *     dispatcher call).
+ *   - A token flipped between steps lets the in-flight step finish,
+ *     then marks the rest "cancelled".
+ *   - `MissionResult.status` is "cancelled" when at least one step
+ *     was preempted.
+ *   - `cancellation_reason` from the token is bubbled into the result.
+ *   - The `cancelled` step has `duration_ms=0` and a `message`
+ *     containing the reason.
+ *
+ *   Transcripts
+ *   -----------
+ *   - The sink fires once per step (including skipped + cancelled).
+ *   - Entries carry mission_id, step_index, step_total, adapter, and
+ *     a clone of the MissionStepResult.
+ *   - A throwing transcript sink does NOT abort the mission (best-effort
+ *     contract per the runner's header).
+ *   - An async transcript sink that rejects also doesn't propagate.
+ *
+ *   Registry
+ *   --------
+ *   - register() returns a usable cancellation token; cancel() flips it.
+ *   - cancel() on an unknown id reports found:false (idempotent).
+ *   - cancel() twice on the same id is idempotent (no throw, no double
+ *     cancellation_reason override unless a new reason was supplied).
+ *   - dispose() removes the entry so subsequent cancel() reports found:false.
+ *   - generateMissionId() produces unique ids.
+ *   - missionTranscriptNamespace(id) === "mission:<id>".
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  runMission,
+  type CapabilityToolBindings,
+  type Mission,
+  type MissionToolDispatcher,
+  type MissionTranscriptEntry,
+} from "../mission.js";
+import {
+  MissionRegistry,
+  generateMissionId,
+  missionTranscriptNamespace,
+} from "../mission-registry.js";
+import type { Capability } from "../capabilities.js";
+
+const CAPS: Capability[] = [
+  { id: "drive_base", verb: "drive", description: "drive", source: { kind: "builtin" } },
+  { id: "take_snapshot", verb: "see", description: "see", source: { kind: "builtin" } },
+];
+
+const BINDINGS: CapabilityToolBindings = {
+  drive_base: {
+    tool: "ros2_publish",
+    buildArgs: (inputs) => ({ topic: "cmd_vel", msg: inputs }),
+  },
+  take_snapshot: {
+    tool: "ros2_camera_snapshot",
+    buildArgs: () => ({}),
+  },
+};
+
+function makeDispatcher(
+  responses: Record<string, { text: string; outputs?: Record<string, unknown>; isError?: boolean }>,
+  log: Array<{ tool: string; args: Record<string, unknown> }>,
+): MissionToolDispatcher {
+  return async (tool, args) => {
+    log.push({ tool, args });
+    return responses[tool] ?? { text: `(no stub for ${tool})` };
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Cancellation
+// ─────────────────────────────────────────────────────────────────────────────
+
+test("cancellation: token flipped before run cancels every step (zero dispatcher calls)", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({}, log);
+  const cancellation = { cancelled: true, reason: "user pressed stop" };
+  const mission: Mission = {
+    name: "drive 3x",
+    steps: [
+      { id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } },
+      { id: "b", capability: "drive_base", inputs: { linear_x: 0.2 } },
+      { id: "c", capability: "drive_base", inputs: { linear_x: 0.3 } },
+    ],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch, {
+    mission_id: "mn_test",
+    cancellation,
+  });
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.steps_run, 0, "no steps executed when cancelled up-front");
+  assert.equal(log.length, 0);
+  assert.equal(result.cancellation_reason, "user pressed stop");
+  for (const s of result.steps) {
+    assert.equal(s.status, "cancelled");
+    assert.equal(s.duration_ms, 0);
+    assert.ok(s.message?.includes("user pressed stop"));
+  }
+});
+
+test("cancellation: token flipped mid-run preempts only remaining steps", async () => {
+  // The dispatcher flips the token while step "a" is in flight. Step
+  // "a" should still finish ok; "b" and "c" should be cancelled.
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const cancellation = { cancelled: false };
+  const dispatch: MissionToolDispatcher = async (tool, args) => {
+    log.push({ tool, args });
+    if (tool === "ros2_publish" && (args as Record<string, unknown>).msg) {
+      const msg = (args as Record<string, unknown>).msg as Record<string, unknown>;
+      if (msg.linear_x === 0.1) cancellation.cancelled = true;
+    }
+    return { text: "ok" };
+  };
+  const mission: Mission = {
+    steps: [
+      { id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } },
+      { id: "b", capability: "drive_base", inputs: { linear_x: 0.2 } },
+      { id: "c", capability: "drive_base", inputs: { linear_x: 0.3 } },
+    ],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch, {
+    mission_id: "mn_test",
+    cancellation,
+  });
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.steps[0].status, "ok", "the in-flight step finished");
+  assert.equal(result.steps[1].status, "cancelled");
+  assert.equal(result.steps[2].status, "cancelled");
+  assert.equal(result.steps_run, 1);
+  assert.equal(log.length, 1, "only step 'a' hit the dispatcher");
+});
+
+test("cancellation: cancellation_reason defaults to 'cancelled' when token doesn't carry one", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({}, log);
+  const mission: Mission = { steps: [{ id: "a", capability: "drive_base" }] };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch, {
+    mission_id: "x",
+    cancellation: { cancelled: true },
+  });
+  assert.equal(result.cancellation_reason, "cancelled");
+});
+
+test("cancellation: mission_id round-trips into MissionResult", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const result = await runMission(
+    { steps: [{ id: "a", capability: "drive_base" }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+    { mission_id: "mn_round_trip" },
+  );
+  assert.equal(result.mission_id, "mn_round_trip");
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Transcripts
+// ─────────────────────────────────────────────────────────────────────────────
+
+test("transcript: sink fires once per step including ok / cancelled", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const cancellation = { cancelled: false };
+  const dispatch: MissionToolDispatcher = async (tool, args) => {
+    log.push({ tool, args });
+    cancellation.cancelled = true;
+    return { text: "ok" };
+  };
+  const entries: MissionTranscriptEntry[] = [];
+  const transcript = (e: MissionTranscriptEntry) => {
+    entries.push(e);
+  };
+  const mission: Mission = {
+    name: "drive then snap",
+    steps: [
+      { id: "drive", capability: "drive_base", inputs: { linear_x: 0.1 } },
+      { id: "snap", capability: "take_snapshot" },
+    ],
+  };
+  await runMission(mission, CAPS, BINDINGS, dispatch, {
+    mission_id: "mn_t",
+    cancellation,
+    transcript,
+    adapter: "test-adapter",
+  });
+  assert.equal(entries.length, 2);
+  assert.equal(entries[0].step_index, 0);
+  assert.equal(entries[0].step_total, 2);
+  assert.equal(entries[0].mission_id, "mn_t");
+  assert.equal(entries[0].adapter, "test-adapter");
+  assert.equal(entries[0].mission_name, "drive then snap");
+  assert.equal(entries[0].result.status, "ok");
+  assert.equal(entries[1].result.status, "cancelled");
+});
+
+test("transcript: a throwing sink does NOT abort the mission (best-effort)", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const result = await runMission(
+    { steps: [{ id: "a", capability: "drive_base" }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+    {
+      mission_id: "mn_t",
+      transcript: () => {
+        throw new Error("transcript backend exploded");
+      },
+    },
+  );
+  assert.equal(result.status, "ok", "mission must complete despite sink throw");
+  assert.equal(result.steps_run, 1);
+});
+
+test("transcript: an async sink that rejects also does NOT surface as unhandled rejection", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const result = await runMission(
+    { steps: [{ id: "a", capability: "drive_base" }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+    {
+      mission_id: "mn_t",
+      transcript: async () => {
+        throw new Error("async sink rejection");
+      },
+    },
+  );
+  assert.equal(result.status, "ok");
+  // If the runner forwards the rejection up the event loop, node:test
+  // will mark this whole run as failed via process.on('unhandledRejection').
+  // A clean exit here is the contract.
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// MissionRegistry + helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+test("registry: register returns a fresh cancellation token; cancel flips it", () => {
+  const reg = new MissionRegistry();
+  const { entry, dispose } = reg.register("mn_1", { name: "test" });
+  assert.equal(entry.cancellation.cancelled, false);
+  const { found, alreadyCancelled } = reg.cancel("mn_1", "user request");
+  assert.equal(found, true);
+  assert.equal(alreadyCancelled, false);
+  assert.equal(entry.cancellation.cancelled, true);
+  assert.equal(entry.cancellation.reason, "user request");
+  dispose();
+});
+
+test("registry: cancel on unknown id reports found:false (no throw)", () => {
+  const reg = new MissionRegistry();
+  const r = reg.cancel("nope");
+  assert.equal(r.found, false);
+});
+
+test("registry: cancel is idempotent — second call says alreadyCancelled", () => {
+  const reg = new MissionRegistry();
+  const { dispose } = reg.register("mn_dup");
+  const first = reg.cancel("mn_dup", "r1");
+  const second = reg.cancel("mn_dup", "r2");
+  assert.equal(first.alreadyCancelled, false);
+  assert.equal(second.alreadyCancelled, true);
+  // Second cancel may update the reason — that's a feature, not a bug
+  // (e.g. "user retry — they really mean it"). Just assert no throw.
+  dispose();
+});
+
+test("registry: dispose removes the entry so subsequent cancel reports found:false", () => {
+  const reg = new MissionRegistry();
+  const { dispose } = reg.register("mn_disp");
+  dispose();
+  assert.equal(reg.cancel("mn_disp").found, false);
+  assert.equal(reg.has("mn_disp"), false);
+});
+
+test("registry: list returns a defensive copy (mutation doesn't bleed back)", () => {
+  const reg = new MissionRegistry();
+  reg.register("mn_l1", { name: "one" });
+  reg.register("mn_l2", { name: "two" });
+  const snapshot = reg.list();
+  assert.equal(snapshot.length, 2);
+  snapshot[0].cancellation.cancelled = true;
+  assert.equal(reg.has("mn_l1"), true);
+  // The internal entry should NOT have been mutated by tampering with
+  // the snapshot's cancellation block.
+  const second = reg.list().find((e) => e.mission_id === "mn_l1");
+  assert.equal(second?.cancellation.cancelled, false);
+});
+
+test("registry: generateMissionId produces unique opaque ids with a stable prefix", () => {
+  const ids = new Set<string>();
+  for (let i = 0; i < 16; i++) ids.add(generateMissionId());
+  assert.equal(ids.size, 16, "16 calls must produce 16 distinct ids");
+  for (const id of ids) {
+    assert.match(id, /^mn_/, `id "${id}" must carry the mn_ prefix`);
+  }
+});
+
+test("registry: missionTranscriptNamespace produces the canonical 'mission:<id>' shape", () => {
+  assert.equal(missionTranscriptNamespace("abc"), "mission:abc");
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// End-to-end glue: registry + runner + custom sink, no memory needed
+// ─────────────────────────────────────────────────────────────────────────────
+
+test("end-to-end: register → run → cancel via registry → transcripts captured", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const reg = new MissionRegistry();
+  const id = generateMissionId();
+  const { entry, dispose } = reg.register(id, { name: "demo" });
+
+  let count = 0;
+  const dispatch: MissionToolDispatcher = async (tool, args) => {
+    log.push({ tool, args });
+    count += 1;
+    // Cancel after the first step finishes — gives us a deterministic
+    // mid-run cancellation without races.
+    if (count === 1) reg.cancel(id, "operator stop");
+    return { text: "ok" };
+  };
+
+  const transcriptEntries: MissionTranscriptEntry[] = [];
+  try {
+    const result = await runMission(
+      {
+        name: "demo",
+        steps: [
+          { id: "s1", capability: "drive_base", inputs: { linear_x: 0.1 } },
+          { id: "s2", capability: "drive_base", inputs: { linear_x: 0.2 } },
+          { id: "s3", capability: "drive_base", inputs: { linear_x: 0.3 } },
+        ],
+      },
+      CAPS,
+      BINDINGS,
+      dispatch,
+      {
+        mission_id: id,
+        cancellation: entry.cancellation,
+        transcript: (e) => {
+          transcriptEntries.push(e);
+        },
+        adapter: "e2e-test",
+      },
+    );
+    assert.equal(result.status, "cancelled");
+    assert.equal(result.mission_id, id);
+    assert.equal(result.cancellation_reason, "operator stop");
+    assert.equal(transcriptEntries.length, 3, "one transcript entry per step");
+    assert.deepEqual(
+      transcriptEntries.map((e) => e.result.status),
+      ["ok", "cancelled", "cancelled"],
+    );
+  } finally {
+    dispose();
+  }
+  assert.equal(reg.has(id), false, "dispose must remove the entry");
+});