agenticros 0.1.18 → 0.1.19

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

@@ -0,0 +1,189 @@
+/**
+ * Unit tests for the memory-backed mission transcript sink.
+ *
+ * Pins down the cross-adapter resume story: a mission run by agent A
+ * leaves a JSON trail under namespace `mission:<id>` that agent B can
+ * read via memory_recall. The sink itself is a thin shim, so we test:
+ *
+ *   - One sink call → exactly one memory.remember() call.
+ *   - Namespace is `mission:<missionId>` (canonical via
+ *     missionTranscriptNamespace).
+ *   - content is JSON-parseable and contains every transcript field
+ *     the LLM cares about (mission_id, step.{id, capability, status,
+ *     inputs, outputs}).
+ *   - tags include `mission_transcript`, `step:<status>`, and
+ *     `capability:<id>` (used for future recall filters).
+ *   - path is sortable (zero-padded step_index) so a recall sorted by
+ *     path returns the steps in execution order.
+ *   - A throwing memory.remember() does NOT propagate (best-effort
+ *     contract — transcript loss must never abort a mission).
+ *   - An async-rejecting memory.remember() doesn't propagate either.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { createMemoryTranscriptSink } from "../mission-transcript-sink.js";
+import { missionTranscriptNamespace } from "../mission-registry.js";
+import type { MissionTranscriptEntry } from "../mission.js";
+import type { MemoryProvider, MemoryRecord } from "../memory/index.js";
+
+interface RememberCall {
+  namespace: string;
+  content: string;
+  tags?: string[];
+  path?: string;
+}
+
+function makeFakeMemory(opts?: {
+  rememberImpl?: (call: RememberCall) => void | Promise<void>;
+}): { memory: MemoryProvider; calls: RememberCall[] } {
+  const calls: RememberCall[] = [];
+  const memory: MemoryProvider = {
+    backend: "local",
+    async remember(input) {
+      const call: RememberCall = {
+        namespace: input.namespace ?? "",
+        content: input.content,
+        tags: input.tags,
+        path: input.path,
+      };
+      calls.push(call);
+      if (opts?.rememberImpl) await opts.rememberImpl(call);
+      return {
+        id: `rec_${calls.length}`,
+        content: input.content,
+        namespace: call.namespace,
+        createdAt: Date.now(),
+      } satisfies MemoryRecord;
+    },
+    async recall() {
+      return [];
+    },
+    async forget() {
+      return { removed: 0 };
+    },
+    async status() {
+      return { enabled: true, backend: "local", namespace: "", recordCount: 0, lastWriteAt: null };
+    },
+    async recent() {
+      return [];
+    },
+  };
+  return { memory, calls };
+}
+
+function makeEntry(opts: Partial<MissionTranscriptEntry> & {
+  step: { id: string; capability: string; status: "ok" | "error" | "skipped" | "cancelled"; outputs?: Record<string, unknown> };
+  step_index: number;
+}): MissionTranscriptEntry {
+  return {
+    mission_id: opts.mission_id ?? "mn_default",
+    mission_name: opts.mission_name,
+    adapter: opts.adapter,
+    started_at: opts.started_at ?? 1700000000000,
+    robot_id: opts.robot_id ?? "",
+    step_index: opts.step_index,
+    step_total: opts.step_total ?? 3,
+    result: {
+      id: opts.step.id,
+      capability: opts.step.capability,
+      status: opts.step.status,
+      inputs: { foo: "bar" },
+      outputs: opts.step.outputs,
+      duration_ms: 42,
+    },
+  };
+}
+
+test("sink: writes one memory.remember per entry, under mission:<id> namespace", async () => {
+  const { memory, calls } = makeFakeMemory();
+  const sink = createMemoryTranscriptSink(memory, "mn_alpha");
+  await sink(makeEntry({ step: { id: "s1", capability: "drive_base", status: "ok" }, step_index: 0 }));
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].namespace, missionTranscriptNamespace("mn_alpha"));
+});
+
+test("sink: content is JSON-parseable and carries the full step snapshot", async () => {
+  const { memory, calls } = makeFakeMemory();
+  const sink = createMemoryTranscriptSink(memory, "mn_beta");
+  await sink(
+    makeEntry({
+      mission_id: "mn_beta",
+      mission_name: "demo",
+      adapter: "claude-code",
+      step: {
+        id: "find",
+        capability: "find_object",
+        status: "ok",
+        outputs: { found: true, horizontal_offset: 0.12 },
+      },
+      step_index: 1,
+      step_total: 3,
+    }),
+  );
+  const payload = JSON.parse(calls[0].content) as {
+    mission_id: string;
+    mission_name: string;
+    adapter: string;
+    step_index: number;
+    step_total: number;
+    step: {
+      id: string;
+      capability: string;
+      status: string;
+      inputs: Record<string, unknown>;
+      outputs: Record<string, unknown>;
+    };
+  };
+  assert.equal(payload.mission_id, "mn_beta");
+  assert.equal(payload.mission_name, "demo");
+  assert.equal(payload.adapter, "claude-code");
+  assert.equal(payload.step_index, 1);
+  assert.equal(payload.step_total, 3);
+  assert.equal(payload.step.id, "find");
+  assert.equal(payload.step.capability, "find_object");
+  assert.equal(payload.step.status, "ok");
+  assert.deepEqual(payload.step.outputs, { found: true, horizontal_offset: 0.12 });
+});
+
+test("sink: tags include mission_transcript + step:<status> + capability:<id>", async () => {
+  const { memory, calls } = makeFakeMemory();
+  const sink = createMemoryTranscriptSink(memory, "mn_g");
+  await sink(makeEntry({ step: { id: "drive", capability: "drive_base", status: "ok" }, step_index: 0 }));
+  await sink(makeEntry({ step: { id: "bad", capability: "find_object", status: "error" }, step_index: 1 }));
+  assert.deepEqual(new Set(calls[0].tags), new Set(["mission_transcript", "step:ok", "capability:drive_base"]));
+  assert.deepEqual(new Set(calls[1].tags), new Set(["mission_transcript", "step:error", "capability:find_object"]));
+});
+
+test("sink: path uses zero-padded step_index so recall sort-by-path stays in execution order", async () => {
+  const { memory, calls } = makeFakeMemory();
+  const sink = createMemoryTranscriptSink(memory, "mn_p");
+  await sink(makeEntry({ step: { id: "s1", capability: "drive_base", status: "ok" }, step_index: 0 }));
+  await sink(makeEntry({ step: { id: "s11", capability: "drive_base", status: "ok" }, step_index: 10 }));
+  // Lexicographic sort of the two paths must put step 0 before step 10.
+  assert.equal(calls[0].path, "mn_p/000-s1");
+  assert.equal(calls[1].path, "mn_p/010-s11");
+  const sorted = [...calls].map((c) => c.path!).sort();
+  assert.deepEqual(sorted, ["mn_p/000-s1", "mn_p/010-s11"]);
+});
+
+test("sink: synchronous throws inside memory.remember don't propagate (best-effort)", async () => {
+  const { memory } = makeFakeMemory({
+    rememberImpl: () => {
+      throw new Error("boom");
+    },
+  });
+  const sink = createMemoryTranscriptSink(memory, "mn_z");
+  // Must not throw.
+  await sink(makeEntry({ step: { id: "s1", capability: "drive_base", status: "ok" }, step_index: 0 }));
+});
+
+test("sink: async rejections inside memory.remember don't propagate", async () => {
+  const { memory } = makeFakeMemory({
+    rememberImpl: async () => {
+      throw new Error("async boom");
+    },
+  });
+  const sink = createMemoryTranscriptSink(memory, "mn_zz");
+  await sink(makeEntry({ step: { id: "s1", capability: "drive_base", status: "ok" }, step_index: 0 }));
+});

package/runtime/packages/core/src/__tests__/mission.test.ts

@@ -0,0 +1,501 @@
+/**
+ * Unit tests for the Phase 1.c mission runner.
+ *
+ * These tests don't need a live transport — they exercise the runner with
+ * a fake dispatcher that records the tool calls and returns canned
+ * responses. The goal is to pin down the behaviour the LLM relies on:
+ *
+ *   - Steps execute in declaration order.
+ *   - `{{stepId.outputs.field}}` resolves from prior step outputs.
+ *   - Single-template strings preserve type (numeric outputs stay numeric).
+ *   - Unknown capabilities fail with a clear, actionable message.
+ *   - Capabilities without a binding fail with a clear, actionable message.
+ *   - `on_fail: "continue"` skips ahead instead of aborting.
+ *   - `on_fail: "stop"` (default) aborts and marks remaining steps "skipped".
+ *   - Tool exceptions are caught and converted to step errors.
+ *   - Tool isError flag propagates to step status.
+ *   - JSON outputs are auto-parsed from the text payload when the binding
+ *     doesn't supply a parseOutputs hook.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  runMission,
+  type CapabilityToolBindings,
+  type Mission,
+  type MissionToolDispatcher,
+} from "../mission.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" },
+  },
+  {
+    id: "find_object",
+    verb: "find",
+    description: "find",
+    source: { kind: "skill", skillId: "find", package: "agenticros-skill-find" },
+  },
+  {
+    id: "no_binding_cap",
+    verb: "demo",
+    description: "Registered but has no binding entry.",
+    source: { kind: "skill", skillId: "demo", package: "agenticros-skill-demo" },
+  },
+];
+
+function makeDispatcher(
+  responses: Record<string, { text: string; outputs?: Record<string, unknown>; isError?: boolean } | Error>,
+  log: Array<{ tool: string; args: Record<string, unknown> }>,
+): MissionToolDispatcher {
+  return async (tool, args) => {
+    log.push({ tool, args });
+    const r = responses[tool];
+    if (!r) return { text: `(no response stub for ${tool})` };
+    if (r instanceof Error) throw r;
+    return r;
+  };
+}
+
+const BINDINGS: CapabilityToolBindings = {
+  drive_base: {
+    tool: "ros2_publish",
+    buildArgs: (inputs) => ({
+      topic: "cmd_vel",
+      msg_type: "geometry_msgs/Twist",
+      msg: {
+        linear: { x: inputs.linear_x ?? 0, y: 0, z: 0 },
+        angular: { x: 0, y: 0, z: inputs.angular_z ?? 0 },
+      },
+    }),
+  },
+  take_snapshot: {
+    tool: "ros2_camera_snapshot",
+    buildArgs: () => ({}),
+  },
+  find_object: {
+    tool: "ros2_find_object",
+    buildArgs: (inputs) => ({ target: inputs.target, timeout_s: inputs.timeout_s ?? 20 }),
+  },
+};
+
+test("mission: empty mission returns ok with no steps", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({}, log);
+  const result = await runMission({ steps: [] }, CAPS, BINDINGS, dispatch);
+  assert.equal(result.status, "ok");
+  assert.equal(result.steps_total, 0);
+  assert.equal(result.steps_run, 0);
+  assert.equal(log.length, 0);
+});
+
+test("mission: single-step success dispatches the right tool with the right args", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    { ros2_publish: { text: "Published." } },
+    log,
+  );
+  const mission: Mission = {
+    name: "drive forward",
+    steps: [{ id: "go", capability: "drive_base", inputs: { linear_x: 0.3 } }],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch);
+  assert.equal(result.status, "ok");
+  assert.equal(result.steps_run, 1);
+  assert.equal(log.length, 1);
+  assert.equal(log[0].tool, "ros2_publish");
+  assert.deepEqual(log[0].args, {
+    topic: "cmd_vel",
+    msg_type: "geometry_msgs/Twist",
+    msg: { linear: { x: 0.3, y: 0, z: 0 }, angular: { x: 0, y: 0, z: 0 } },
+  });
+});
+
+test("mission: template substitution preserves numeric type for whole-string refs", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: {
+        text: '{"found": true, "horizontal_offset": 0.42}',
+      },
+      ros2_publish: { text: "Published." },
+    },
+    log,
+  );
+  const mission: Mission = {
+    name: "find chair then nudge",
+    steps: [
+      { id: "find", capability: "find_object", inputs: { target: "chair" } },
+      {
+        id: "nudge",
+        capability: "drive_base",
+        inputs: { linear_x: 0.2, angular_z: "{{find.outputs.horizontal_offset}}" },
+      },
+    ],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch);
+  assert.equal(result.status, "ok", result.summary);
+  assert.equal(log.length, 2);
+  // The crucial assertion: angular_z is a NUMBER (0.42), not the string "0.42".
+  const nudgeArgs = log[1].args;
+  const msg = nudgeArgs.msg as { angular: { z: unknown } };
+  assert.equal(msg.angular.z, 0.42);
+  assert.equal(typeof msg.angular.z, "number");
+});
+
+test("mission: template substitution works inside string interpolation", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  // Add a capability whose buildArgs uses a string input.
+  const bindings: CapabilityToolBindings = {
+    ...BINDINGS,
+    take_snapshot: {
+      tool: "ros2_camera_snapshot",
+      buildArgs: (inputs) => ({ label: inputs.label }),
+    },
+    find_object: {
+      tool: "ros2_find_object",
+      buildArgs: (inputs) => ({ target: inputs.target }),
+    },
+  };
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: { text: '{"found": true, "object": "chair"}' },
+      ros2_camera_snapshot: { text: "Snapshot taken." },
+    },
+    log,
+  );
+  const mission: Mission = {
+    steps: [
+      { id: "find", capability: "find_object", inputs: { target: "chair" } },
+      {
+        id: "snap",
+        capability: "take_snapshot",
+        inputs: { label: "After finding a {{find.outputs.object}}." },
+      },
+    ],
+  };
+  const result = await runMission(mission, CAPS, bindings, dispatch);
+  assert.equal(result.status, "ok");
+  assert.equal(log[1].args.label, "After finding a chair.");
+});
+
+test("mission: unknown capability fails with actionable message", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({}, log);
+  const result = await runMission(
+    { steps: [{ id: "x", capability: "doesnt_exist" }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "error");
+  assert.equal(result.steps[0].status, "error");
+  assert.ok(result.steps[0].error?.includes("ros2_list_capabilities"));
+  assert.equal(log.length, 0);
+});
+
+test("mission: registered capability without a binding fails clearly", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({}, log);
+  const result = await runMission(
+    { steps: [{ id: "x", capability: "no_binding_cap" }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "error");
+  assert.ok(result.steps[0].error?.includes("no mission-runner tool binding"));
+  assert.equal(log.length, 0);
+});
+
+test("mission: on_fail=stop (default) aborts and skips remaining steps", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: { text: "Object not found.", isError: true },
+      ros2_publish: { text: "Published." },
+    },
+    log,
+  );
+  const mission: Mission = {
+    steps: [
+      { id: "find", capability: "find_object", inputs: { target: "chair" } },
+      { id: "go", capability: "drive_base", inputs: { linear_x: 0.2 } },
+    ],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch);
+  assert.equal(result.status, "error");
+  assert.equal(result.steps[0].status, "error");
+  assert.equal(result.steps[1].status, "skipped");
+  assert.equal(result.steps_run, 1, "only one step actually ran");
+  assert.equal(log.length, 1, "drive should never have been dispatched");
+});
+
+test("mission: on_fail=continue runs subsequent steps even after failure", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: { text: "Object not found.", isError: true },
+      ros2_publish: { text: "Published." },
+    },
+    log,
+  );
+  const mission: Mission = {
+    steps: [
+      { id: "find", capability: "find_object", inputs: { target: "chair" }, on_fail: "continue" },
+      { id: "go", capability: "drive_base", inputs: { linear_x: 0.2 } },
+    ],
+  };
+  const result = await runMission(mission, CAPS, BINDINGS, dispatch);
+  assert.equal(result.status, "error", "overall status remains error if any step failed");
+  assert.equal(result.steps[0].status, "error");
+  assert.equal(result.steps[1].status, "ok");
+  assert.equal(result.steps_run, 2);
+  assert.equal(log.length, 2);
+});
+
+test("mission: tool exceptions are caught and surfaced as step errors", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    { ros2_publish: new Error("transport disconnected") },
+    log,
+  );
+  const result = await runMission(
+    {
+      steps: [{ id: "x", capability: "drive_base", inputs: { linear_x: 0.1 } }],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "error");
+  assert.equal(result.steps[0].error, "transport disconnected");
+});
+
+test("mission: outputs are auto-parsed from JSON text when binding has no parseOutputs", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: { text: '{"found": true, "horizontal_offset": 0.1}' },
+    },
+    log,
+  );
+  const result = await runMission(
+    { steps: [{ id: "find", capability: "find_object", inputs: { target: "chair" } }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "ok");
+  assert.deepEqual(result.steps[0].outputs, { found: true, horizontal_offset: 0.1 });
+});
+
+test("mission: explicit outputs from dispatcher take precedence over auto-parse", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    {
+      ros2_find_object: {
+        text: '{"found": true, "horizontal_offset": 0.1}',
+        outputs: { found: true, horizontal_offset: 0.9, source: "explicit" },
+      },
+    },
+    log,
+  );
+  const result = await runMission(
+    { steps: [{ id: "find", capability: "find_object", inputs: { target: "chair" } }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.steps[0].outputs?.source, "explicit");
+  assert.equal(result.steps[0].outputs?.horizontal_offset, 0.9);
+});
+
+test("mission: summary line reports success counts when all green", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const result = await runMission(
+    {
+      name: "patrol",
+      steps: [
+        { id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } },
+        { id: "b", capability: "drive_base", inputs: { linear_x: 0.0 } },
+      ],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "ok");
+  assert.ok(result.summary.includes("patrol"));
+  assert.ok(result.summary.includes("2/2"));
+});
+
+test("mission: summary line names the failed step when any step errored", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher(
+    { ros2_publish: { text: "boom", isError: true } },
+    log,
+  );
+  const result = await runMission(
+    {
+      name: "wave-and-go",
+      steps: [{ id: "go", capability: "drive_base", inputs: { linear_x: 0.1 } }],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "error");
+  assert.ok(result.summary.includes('"go"'));
+});
+
+// --- Phase 1.d: multi-robot routing tests ---
+//
+// These pin down the robot_id injection contract that adapters depend on.
+// The runner is transport-agnostic so it doesn't validate the id itself —
+// it just makes sure the right id ends up in toolArgs.robot_id for every
+// dispatched call, following the documented precedence:
+//   1. binding.buildArgs set it    (left alone)
+//   2. step.inputs.robot_id        (per-step override)
+//   3. mission.robot_id            (mission-level default)
+//   4. none                        (no robot_id key on toolArgs)
+//
+// Empty/whitespace strings at levels 2-3 are treated as "not set" so
+// agents can leave them empty without accidentally pinning to "".
+
+test("mission: mission.robot_id is injected into every dispatched tool's args", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const result = await runMission(
+    {
+      name: "drive-alpha",
+      robot_id: "alpha",
+      steps: [
+        { id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } },
+        { id: "b", capability: "drive_base", inputs: { linear_x: 0.2 } },
+      ],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(result.status, "ok");
+  assert.equal(log.length, 2);
+  for (const entry of log) {
+    assert.equal(entry.args.robot_id, "alpha", `every dispatched tool call must carry robot_id=alpha (got ${JSON.stringify(entry.args.robot_id)})`);
+  }
+  assert.equal(result.robot_id, "alpha", "result should surface the mission-level robot_id");
+});
+
+test("mission: per-step inputs.robot_id overrides mission.robot_id for that step", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  await runMission(
+    {
+      robot_id: "alpha",
+      steps: [
+        { id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } },
+        { id: "b", capability: "drive_base", inputs: { linear_x: 0.2, robot_id: "beta" } },
+        { id: "c", capability: "drive_base", inputs: { linear_x: 0.3 } },
+      ],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(log[0].args.robot_id, "alpha", "step a falls back to mission default");
+  assert.equal(log[1].args.robot_id, "beta", "step b's inputs.robot_id wins");
+  assert.equal(log[2].args.robot_id, "alpha", "step c falls back to mission default again");
+});
+
+test("mission: no robot_id at any level leaves toolArgs untouched", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  await runMission(
+    { steps: [{ id: "a", capability: "drive_base", inputs: { linear_x: 0.1 } }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(log.length, 1);
+  assert.ok(!("robot_id" in log[0].args), "robot_id must not be added when no level set it");
+});
+
+test("mission: empty / whitespace robot_id strings are treated as unset", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  await runMission(
+    {
+      robot_id: "   ",
+      steps: [
+        { id: "a", capability: "drive_base", inputs: { linear_x: 0.1, robot_id: "" } },
+        { id: "b", capability: "drive_base", inputs: { linear_x: 0.2 } },
+      ],
+    },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.ok(!("robot_id" in log[0].args), "step-level empty string falls through to mission, mission's whitespace = unset");
+  assert.ok(!("robot_id" in log[1].args), "no override + whitespace mission = unset");
+});
+
+test("mission: binding-supplied robot_id wins over both inputs and mission", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  // A binding that hard-codes robot_id (a rare but legal pattern — e.g. a
+  // capability that targets a fixed companion robot regardless of the
+  // mission default).
+  const bindings: CapabilityToolBindings = {
+    ...BINDINGS,
+    drive_base: {
+      tool: "ros2_publish",
+      buildArgs: (inputs) => ({
+        topic: "cmd_vel",
+        robot_id: "binding-pinned",
+        msg: { linear: { x: inputs.linear_x ?? 0 } },
+      }),
+    },
+  };
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  await runMission(
+    {
+      robot_id: "alpha",
+      steps: [{ id: "a", capability: "drive_base", inputs: { linear_x: 0.1, robot_id: "beta" } }],
+    },
+    CAPS,
+    bindings,
+    dispatch,
+  );
+  assert.equal(log[0].args.robot_id, "binding-pinned", "binding's robot_id must not be overwritten");
+});
+
+test("mission: result.robot_id reflects the mission-level default (empty when unset)", async () => {
+  const log: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const dispatch = makeDispatcher({ ros2_publish: { text: "ok" } }, log);
+  const a = await runMission(
+    { robot_id: "alpha", steps: [{ id: "x", capability: "drive_base", inputs: { linear_x: 0.1 } }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  const b = await runMission(
+    { steps: [{ id: "x", capability: "drive_base", inputs: { linear_x: 0.1 } }] },
+    CAPS,
+    BINDINGS,
+    dispatch,
+  );
+  assert.equal(a.robot_id, "alpha");
+  assert.equal(b.robot_id, "");
+});