agenticros 0.1.18 → 0.2.0

package/runtime/packages/agenticros-claude-code/src/__tests__/follow-me-registry.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Per-robot isolation tests for the follow-me + find-object skill registries.
+ *
+ * Phase 1.d-extend asserts that each robot keeps its own independent
+ * follow-me loop instance, keyed by `robot.id`. If two robots ever share a
+ * single loop, starting follow-me on one would silently steer the other
+ * and `ros2_follow_me_status` would conflate state — exactly the regression
+ * this suite is designed to catch.
+ *
+ * These tests run as pure registry checks — they construct a minimal mock
+ * `RosTransport` so the loop constructors don't reach for the network, and
+ * they reset the registry between tests so suites stay deterministic.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { ResolvedRobot, RosTransport } from "@agenticros/core";
+import {
+  getFollowMeDepth,
+  _resetFollowMeDepthRegistry,
+} from "../follow-me/depth-loop.js";
+import {
+  getFollowMeLocal,
+  _resetFollowMeLocalRegistry,
+} from "../follow-me/loop.js";
+import { parseConfig } from "@agenticros/core";
+
+/**
+ * Minimal `RosTransport` stub. The follow-me loops only touch the transport
+ * inside `start()` (subscribe + publish) — the constructor + registry path
+ * never call into it. We provide a no-op surface so TypeScript is happy and
+ * any accidental call surfaces as an obvious "TypeError: ... not a function".
+ */
+function stubTransport(): RosTransport {
+  // The follow-me loop constructors don't touch the transport — they only
+  // call into it from `start()`. We cast through `unknown` so the test
+  // doesn't have to track the full RosTransport surface area; any
+  // accidental method call surfaces as a clean "not a function" error.
+  return {} as unknown as RosTransport;
+}
+
+function makeRobot(id: string, namespace: string): ResolvedRobot {
+  return {
+    id,
+    name: id,
+    namespace,
+    cameraTopic: "",
+    kind: "amr",
+    sensors: { has_realsense: false, has_lidar: false, has_arm: false },
+    source: "config",
+  };
+}
+
+const CONFIG = parseConfig({ robot: { namespace: "robot-a" } });
+
+test("follow-me-registry: getFollowMeDepth returns the same instance for the same robot.id", () => {
+  _resetFollowMeDepthRegistry();
+  const transport = stubTransport();
+  const robotA = makeRobot("robot-a", "robot-a");
+  const first = getFollowMeDepth(robotA, CONFIG, transport);
+  const second = getFollowMeDepth(robotA, CONFIG, transport);
+  assert.strictEqual(
+    first,
+    second,
+    "two calls with the same robot.id must return the identical loop instance",
+  );
+  assert.equal(first.robotId, "robot-a", "instance should remember its robot.id");
+});
+
+test("follow-me-registry: getFollowMeDepth returns DIFFERENT instances for DIFFERENT robot.ids", () => {
+  _resetFollowMeDepthRegistry();
+  const transport = stubTransport();
+  const robotA = makeRobot("robot-a", "robot-a");
+  const robotB = makeRobot("robot-b", "robot-b");
+  const loopA = getFollowMeDepth(robotA, CONFIG, transport);
+  const loopB = getFollowMeDepth(robotB, CONFIG, transport);
+  assert.notStrictEqual(loopA, loopB, "each robot must get its own independent loop");
+  assert.equal(loopA.robotId, "robot-a");
+  assert.equal(loopB.robotId, "robot-b");
+  // And a follow-up lookup must still return each robot's own loop, not
+  // the most-recently-created one.
+  assert.strictEqual(getFollowMeDepth(robotA, CONFIG, transport), loopA);
+  assert.strictEqual(getFollowMeDepth(robotB, CONFIG, transport), loopB);
+});
+
+test("follow-me-registry: getFollowMeLocal returns the same instance for the same robot.id", () => {
+  _resetFollowMeLocalRegistry();
+  const transport = stubTransport();
+  const robotA = makeRobot("robot-a", "robot-a");
+  const first = getFollowMeLocal(robotA, CONFIG, transport);
+  const second = getFollowMeLocal(robotA, CONFIG, transport);
+  assert.strictEqual(
+    first,
+    second,
+    "two calls with the same robot.id must return the identical loop instance",
+  );
+  assert.equal(first.robotId, "robot-a", "instance should remember its robot.id");
+});
+
+test("follow-me-registry: getFollowMeLocal returns DIFFERENT instances for DIFFERENT robot.ids", () => {
+  _resetFollowMeLocalRegistry();
+  const transport = stubTransport();
+  const robotA = makeRobot("robot-a", "robot-a");
+  const robotB = makeRobot("robot-b", "robot-b");
+  const loopA = getFollowMeLocal(robotA, CONFIG, transport);
+  const loopB = getFollowMeLocal(robotB, CONFIG, transport);
+  assert.notStrictEqual(loopA, loopB, "each robot must get its own independent loop");
+  assert.equal(loopA.robotId, "robot-a");
+  assert.equal(loopB.robotId, "robot-b");
+});
+
+test("follow-me-registry: status() defaults to disabled on a fresh per-robot instance", () => {
+  _resetFollowMeDepthRegistry();
+  const transport = stubTransport();
+  const robot = makeRobot("robot-a", "robot-a");
+  const loop = getFollowMeDepth(robot, CONFIG, transport);
+  const s = loop.status();
+  assert.equal(s.enabled, false, "a freshly-registered loop should not be enabled");
+  assert.equal(s.tracking, false, "a freshly-registered loop should not be tracking");
+});

package/runtime/packages/agenticros-claude-code/src/find-object/find-object.ts

@@ -3,7 +3,7 @@
  * camera feed, then stop. Used by the ros2_find_object MCP tool.
  */
 
-import type { AgenticROSConfig, RosTransport } from "@agenticros/core";
+import type { AgenticROSConfig, ResolvedRobot, RosTransport } from "@agenticros/core";
 import { resolveCameraSubscribeTopic, toNamespacedTopic } from "@agenticros/core";
 import {
   ROS_MSG_COMPRESSED_IMAGE,
@@ -48,6 +48,7 @@ export interface FindObjectResult {
 }
 
 export async function findObject(
+  robot: ResolvedRobot,
   config: AgenticROSConfig,
   transport: RosTransport,
   opts: FindObjectOptions,
@@ -78,10 +79,10 @@ export async function findObject(
   const detector = new PersonDetector({ scoreThreshold: minConfidence });
   await detector.load();
 
-  const cmdVelTopic = resolveCmdVelTopic(config);
+  const cmdVelTopic = resolveCmdVelTopic(config, robot);
   const colorTopic = resolveCameraSubscribeTopic(
-    config,
-    (config.robot?.cameraTopic ?? "").trim() || DEFAULT_COLOR_TOPIC,
+    robot.namespace,
+    robot.cameraTopic.trim() || DEFAULT_COLOR_TOPIC,
   );
 
   const startedAt = Date.now();
@@ -178,9 +179,9 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function resolveCmdVelTopic(config: AgenticROSConfig): string {
+function resolveCmdVelTopic(config: AgenticROSConfig, robot: ResolvedRobot): string {
   const raw = (config.teleop?.cmdVelTopic ?? "").trim() || "/cmd_vel";
-  const namespaced = toNamespacedTopic(config, raw);
+  const namespaced = toNamespacedTopic(robot.namespace, raw);
   const match = namespaced.match(/^\/([^/]+)\/cmd_vel$/i);
   const segment = match?.[1] ?? "";
   if (match && !segment.toLowerCase().startsWith("robot")) {

package/runtime/packages/agenticros-claude-code/src/follow-me/depth-loop.ts

@@ -20,7 +20,12 @@
  * person re-identification.
  */
 
-import type { AgenticROSConfig, RosTransport, Subscription } from "@agenticros/core";
+import type {
+  AgenticROSConfig,
+  ResolvedRobot,
+  RosTransport,
+  Subscription,
+} from "@agenticros/core";
 import { resolveCameraSubscribeTopic, toNamespacedTopic } from "@agenticros/core";
 import {
   ROS_MSG_IMAGE,
@@ -93,10 +98,16 @@ export class FollowMeDepth {
   private tracking = false;
 
   constructor(
+    private readonly robot: ResolvedRobot,
     private readonly config: AgenticROSConfig,
     private readonly transport: RosTransport,
   ) {}
 
+  /** Stable id of the robot this loop is bound to. Used by the registry below. */
+  get robotId(): string {
+    return this.robot.id;
+  }
+
   async start(opts: StartOptions = {}): Promise<void> {
     if (this.enabled) return;
     this.lastError = null;
@@ -145,7 +156,7 @@ export class FollowMeDepth {
   }
 
   private subscribeDepth(): void {
-    const depthTopic = resolveCameraSubscribeTopic(this.config, DEFAULT_DEPTH_TOPIC);
+    const depthTopic = resolveCameraSubscribeTopic(this.robot.namespace, DEFAULT_DEPTH_TOPIC);
     this.depthSub = this.transport.subscribe(
       { topic: depthTopic, type: ROS_MSG_IMAGE },
       (msg) => {
@@ -228,7 +239,7 @@ export class FollowMeDepth {
   }
 
   private async publishTwist(twist: Twist): Promise<void> {
-    const topic = resolveCmdVelTopic(this.config);
+    const topic = resolveCmdVelTopic(this.config, this.robot);
     const message = {
       linear: { x: twist.linearX, y: 0, z: 0 },
       angular: { x: 0, y: 0, z: twist.angularZ },
@@ -401,9 +412,9 @@ function sampleCellBand(
   return n;
 }
 
-function resolveCmdVelTopic(config: AgenticROSConfig): string {
+function resolveCmdVelTopic(config: AgenticROSConfig, robot: ResolvedRobot): string {
   const raw = (config.teleop?.cmdVelTopic ?? "").trim() || "/cmd_vel";
-  const namespaced = toNamespacedTopic(config, raw);
+  const namespaced = toNamespacedTopic(robot.namespace, raw);
   const match = namespaced.match(/^\/([^/]+)\/cmd_vel$/i);
   const segment = match?.[1] ?? "";
   if (match && !segment.toLowerCase().startsWith("robot")) {
@@ -412,9 +423,30 @@ function resolveCmdVelTopic(config: AgenticROSConfig): string {
   return namespaced;
 }
 
-let singleton: FollowMeDepth | null = null;
+/**
+ * Per-robot registry. Each robot gets its own `FollowMeDepth` instance the
+ * first time anyone asks for one — multi-robot Phase 1.d-extend.
+ *
+ * Keying by `robot.id` (not the namespace string) so two configs that resolve
+ * to the same id share the same loop, and a config swap that *changes* the id
+ * yields a fresh loop with fresh subscriptions.
+ */
+const instances = new Map<string, FollowMeDepth>();
+
+export function getFollowMeDepth(
+  robot: ResolvedRobot,
+  config: AgenticROSConfig,
+  transport: RosTransport,
+): FollowMeDepth {
+  let entry = instances.get(robot.id);
+  if (!entry) {
+    entry = new FollowMeDepth(robot, config, transport);
+    instances.set(robot.id, entry);
+  }
+  return entry;
+}
 
-export function getFollowMeDepth(config: AgenticROSConfig, transport: RosTransport): FollowMeDepth {
-  if (!singleton) singleton = new FollowMeDepth(config, transport);
-  return singleton;
+/** Test-only: clear the registry so suites can run in isolation. */
+export function _resetFollowMeDepthRegistry(): void {
+  instances.clear();
 }

package/runtime/packages/agenticros-claude-code/src/follow-me/loop.ts

@@ -5,7 +5,12 @@
  * This is the `mode: 'local'` alternative to the agenticros_follow_me ROS2 node.
  */
 
-import type { AgenticROSConfig, RosTransport, Subscription } from "@agenticros/core";
+import type {
+  AgenticROSConfig,
+  ResolvedRobot,
+  RosTransport,
+  Subscription,
+} from "@agenticros/core";
 import { resolveCameraSubscribeTopic, toNamespacedTopic } from "@agenticros/core";
 import {
   ROS_MSG_COMPRESSED_IMAGE,
@@ -75,10 +80,16 @@ export class FollowMeLocal {
   private tracking = false;
 
   constructor(
+    private readonly robot: ResolvedRobot,
     private readonly config: AgenticROSConfig,
     private readonly transport: RosTransport,
   ) {}
 
+  /** Stable id of the robot this loop is bound to. Used by the registry below. */
+  get robotId(): string {
+    return this.robot.id;
+  }
+
   async start(opts: StartOptions = {}): Promise<void> {
     if (this.enabled) return;
     this.lastError = null;
@@ -129,9 +140,9 @@ export class FollowMeLocal {
   }
 
   private subscribeFrames(): void {
-    const colorTopicRaw = (this.config.robot?.cameraTopic ?? "").trim() || DEFAULT_COLOR_TOPIC;
-    const colorTopic = resolveCameraSubscribeTopic(this.config, colorTopicRaw);
-    const depthTopic = resolveCameraSubscribeTopic(this.config, DEFAULT_DEPTH_TOPIC);
+    const colorTopicRaw = this.robot.cameraTopic.trim() || DEFAULT_COLOR_TOPIC;
+    const colorTopic = resolveCameraSubscribeTopic(this.robot.namespace, colorTopicRaw);
+    const depthTopic = resolveCameraSubscribeTopic(this.robot.namespace, DEFAULT_DEPTH_TOPIC);
     const isCompressed = colorTopic.includes("compressed");
 
     this.colorSub = this.transport.subscribe(
@@ -261,7 +272,7 @@ export class FollowMeLocal {
   }
 
   private async publishTwist(twist: Twist): Promise<void> {
-    const topic = resolveCmdVelTopic(this.config);
+    const topic = resolveCmdVelTopic(this.config, this.robot);
     const message = {
       linear: { x: twist.linearX, y: 0, z: 0 },
       angular: { x: 0, y: 0, z: twist.angularZ },
@@ -310,9 +321,9 @@ function sampleDepthRegion(d: LatestDepth, x0: number, y0: number, x1: number, y
   return out;
 }
 
-function resolveCmdVelTopic(config: AgenticROSConfig): string {
+function resolveCmdVelTopic(config: AgenticROSConfig, robot: ResolvedRobot): string {
   const raw = (config.teleop?.cmdVelTopic ?? "").trim() || "/cmd_vel";
-  const namespaced = toNamespacedTopic(config, raw);
+  const namespaced = toNamespacedTopic(robot.namespace, raw);
   // Apply same uuid → robot<uuid-no-dashes> rewrite as ros2_publish handler.
   const match = namespaced.match(/^\/([^/]+)\/cmd_vel$/i);
   const segment = match?.[1] ?? "";
@@ -322,9 +333,27 @@ function resolveCmdVelTopic(config: AgenticROSConfig): string {
   return namespaced;
 }
 
-let singleton: FollowMeLocal | null = null;
+/**
+ * Per-robot registry. Each robot gets its own `FollowMeLocal` instance (with
+ * its own YOLO detector + camera subs) the first time anyone asks for one.
+ * Multi-robot Phase 1.d-extend.
+ */
+const instances = new Map<string, FollowMeLocal>();
+
+export function getFollowMeLocal(
+  robot: ResolvedRobot,
+  config: AgenticROSConfig,
+  transport: RosTransport,
+): FollowMeLocal {
+  let entry = instances.get(robot.id);
+  if (!entry) {
+    entry = new FollowMeLocal(robot, config, transport);
+    instances.set(robot.id, entry);
+  }
+  return entry;
+}
 
-export function getFollowMeLocal(config: AgenticROSConfig, transport: RosTransport): FollowMeLocal {
-  if (!singleton) singleton = new FollowMeLocal(config, transport);
-  return singleton;
+/** Test-only: clear the registry so suites can run in isolation. */
+export function _resetFollowMeLocalRegistry(): void {
+  instances.clear();
 }

package/runtime/packages/agenticros-claude-code/src/index.ts

@@ -15,7 +15,7 @@ import type { AgenticROSConfig } from "@agenticros/core";
 import { renderAgenticROSBanner } from "@agenticros/core";
 import { loadConfig } from "./config.js";
 import { connect, disconnect } from "./transport.js";
-import { TOOLS, handleToolCall, MEMORY_TOOL_NAMES } from "./tools.js";
+import { TOOLS, handleToolCall, MEMORY_TOOL_NAMES, NO_TRANSPORT_TOOL_NAMES } from "./tools.js";
 import { ensureMemory } from "./memory.js";
 
 let config: AgenticROSConfig | null = null;
@@ -81,10 +81,10 @@ function main(): void {
       process.stderr.write(
         `[AgenticROS] Config: robot.namespace=${ns ? `"${ns}"` : '""'} → ${ns ? `/${ns}/cmd_vel` : "/cmd_vel"}\n`,
       );
-      // Memory tools are self-contained — they don't talk to the robot, so
-      // don't force a Zenoh/ROS transport connection (and don't fail if zenohd
-      // isn't running). Every other tool needs the transport up.
-      if (!MEMORY_TOOL_NAMES.has(name)) {
+      // Tools that don't need the ROS transport (memory + capabilities) are
+      // self-contained — skip `ensureConnected()` so they work even when
+      // zenohd is down. Every other tool needs the transport up.
+      if (!NO_TRANSPORT_TOOL_NAMES.has(name)) {
         await ensureConnected();
       }
       const result = await handleToolCall(name, args ?? {}, config);

package/runtime/packages/agenticros-claude-code/src/mission-registry.ts

@@ -0,0 +1,21 @@
+/**
+ * Per-process singleton mission registry for the Claude Code MCP server.
+ *
+ * Each `run_mission` invocation registers a fresh `mission_id` here so
+ * a sibling `mission_cancel` MCP call can flip the cancellation token
+ * mid-run. The runner picks that up at the next step boundary and
+ * gracefully marks remaining steps as "cancelled".
+ *
+ * Lives at the module scope (not as a per-request object) because MCP
+ * tool calls are dispatched independently — the cancel tool has no
+ * other way to find the in-flight mission. See
+ * docs/strategy-ai-agents-plus-ros.md §4 Phase 1.f.
+ */
+
+import { MissionRegistry } from "@agenticros/core";
+
+const registry = new MissionRegistry();
+
+export function getMissionRegistry(): MissionRegistry {
+  return registry;
+}