@mastra/server 1.47.0-alpha.5 → 1.47.0-alpha.6

package/dist/{chunk-3WE5YAL5.js → chunk-RLAOC73C.js}

@@ -6,19 +6,19 @@ import { z } from 'zod/v4';
 function isReservedThreadMetadataKey(key) {
   return key === "currentModelId" || key === "currentModeId" || key === "observerModelId" || key === "reflectorModelId" || key === "observationThreshold" || key === "reflectionThreshold" || key === "tokenUsage" || key.startsWith("modeModelId_");
 }
-function getHarnessOrThrow(mastra, harnessId) {
-  const harness = mastra.getHarness(harnessId);
-  if (!harness) {
-    throw new HTTPException(404, { message: `harness "${harnessId}" not found` });
+function getAgentControllerOrThrow(mastra, controllerId) {
+  const controller = mastra.getAgentController?.(controllerId);
+  if (!controller) {
+    throw new HTTPException(404, { message: `agent controller "${controllerId}" not found` });
   }
-  return harness;
+  return controller;
 }
-async function getSession(harness, resourceId, tags) {
-  await harness.init();
-  return harness.createSession({ resourceId, id: resourceId, ownerId: harness.id, tags });
+async function getSession(controller, resourceId, tags) {
+  await controller.init();
+  return controller.createSession({ resourceId, id: resourceId, ownerId: controller.id, tags });
 }
-var harnessIdPathParams = z.object({ harnessId: z.string() });
-var sessionPathParams = z.object({ harnessId: z.string(), resourceId: z.string() });
+var controllerIdPathParams = z.object({ controllerId: z.string() });
+var sessionPathParams = z.object({ controllerId: z.string(), resourceId: z.string() });
 var createSessionBodySchema = z.object({
   resourceId: z.string(),
   tags: z.record(z.string(), z.string()).optional()
@@ -45,7 +45,7 @@ var switchModelBodySchema = z.object({
 var switchThreadBodySchema = z.object({ threadId: z.string() });
 var createThreadBodySchema = z.object({ title: z.string().optional() });
 var renameThreadBodySchema = z.object({ title: z.string() });
-var threadPathParams = z.object({ harnessId: z.string(), resourceId: z.string(), threadId: z.string() });
+var threadPathParams = z.object({ controllerId: z.string(), resourceId: z.string(), threadId: z.string() });
 var cloneThreadBodySchema = z.object({
   sourceThreadId: z.string().optional(),
   title: z.string().optional()
@@ -75,11 +75,11 @@ var sendNotificationBodySchema = z.object({
   attributes: z.record(z.string(), z.unknown()).optional(),
   metadata: z.record(z.string(), z.unknown()).optional()
 });
-var listHarnessesResponseSchema = z.object({
-  harnesses: z.array(z.object({ id: z.string() }))
+var listAgentControllersResponseSchema = z.object({
+  agentControllers: z.array(z.object({ id: z.string() }))
 });
 var createSessionResponseSchema = z.object({
-  harnessId: z.string(),
+  controllerId: z.string(),
   resourceId: z.string(),
   threadId: z.string().optional()
 });
@@ -104,7 +104,7 @@ var sessionSettingsSchema = z.object({
   smartEditing: z.boolean()
 });
 var sessionStateResponseSchema = z.object({
-  harnessId: z.string(),
+  controllerId: z.string(),
   resourceId: z.string(),
   threadId: z.string().optional(),
   modeId: z.string(),
@@ -179,67 +179,70 @@ var setToolPermissionBodySchema = z.object({
   toolName: z.string(),
   policy: permissionPolicyEnum
 });
-var LIST_HARNESSES_ROUTE = createRoute({
+var LIST_AGENT_CONTROLLERS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness",
+  path: "/agent-controller",
   responseType: "json",
-  responseSchema: listHarnessesResponseSchema,
-  summary: "List harnesses",
-  description: "Lists the harnesses hosted on this Mastra instance.",
-  tags: ["Harness"],
+  responseSchema: listAgentControllersResponseSchema,
+  summary: "List agent controllers",
+  description: "Lists the agent controllers hosted on this Mastra instance.",
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
+  requiresPermission: "agent-controller:read",
   handler: async ({ mastra }) => {
     try {
-      const harnesses = mastra.listHarnesses();
-      return { harnesses: Object.keys(harnesses).map((id) => ({ id })) };
+      const ids = /* @__PURE__ */ new Set();
+      if (mastra.listAgentControllers) {
+        for (const id of Object.keys(mastra.listAgentControllers())) ids.add(id);
+      }
+      return { agentControllers: Array.from(ids).map((id) => ({ id })) };
     } catch (error) {
-      return handleError(error, "error listing harnesses");
+      return handleError(error, "error listing agent controllers");
     }
   }
 });
-var CREATE_HARNESS_SESSION_ROUTE = createRoute({
+var CREATE_AGENT_CONTROLLER_SESSION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions",
+  path: "/agent-controller/:controllerId/sessions",
   responseType: "json",
-  pathParamSchema: harnessIdPathParams,
+  pathParamSchema: controllerIdPathParams,
   bodySchema: createSessionBodySchema,
   responseSchema: createSessionResponseSchema,
-  summary: "Create or resume a harness session",
+  summary: "Create or resume a controller session",
   description: "Creates a session for the given resourceId, or returns the existing one (get-or-create), so reconnects resume the conversation.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, tags }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, tags }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId, tags);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId, tags);
       return {
-        harnessId,
+        controllerId,
         resourceId,
         threadId: session.thread.getId() ?? void 0
       };
     } catch (error) {
-      return handleError(error, "error creating harness session");
+      return handleError(error, "error creating controller session");
     }
   }
 });
-var STREAM_HARNESS_SESSION_ROUTE = createRoute({
+var STREAM_AGENT_CONTROLLER_SESSION_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/stream",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/stream",
   responseType: "stream",
   streamFormat: "sse",
   sseFlushOnConnect: true,
   pathParamSchema: sessionPathParams,
-  summary: "Stream harness session events",
+  summary: "Stream controller session events",
   description: "Subscribes to a session\u2019s event bus and streams events to the client over SSE.",
-  tags: ["Harness", "Streaming"],
+  tags: ["AgentController", "Streaming"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId, abortSignal }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId, abortSignal }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       let cleanedUp = false;
       let heartbeat;
       let unsubscribe;
@@ -249,20 +252,20 @@ var STREAM_HARNESS_SESSION_ROUTE = createRoute({
           heartbeat = void 0;
         }
       };
-      const cleanup = (controller) => {
+      const cleanup = (controller2) => {
         if (cleanedUp) return;
         cleanedUp = true;
         clearHeartbeat();
         unsubscribe?.();
-        if (controller) {
+        if (controller2) {
           try {
-            controller.close();
+            controller2.close();
           } catch {
           }
         }
       };
       return new ReadableStream({
-        start(controller) {
+        start(controller2) {
           const scheduleHeartbeat = () => {
             if (cleanedUp) return;
             clearHeartbeat();
@@ -270,7 +273,7 @@ var STREAM_HARNESS_SESSION_ROUTE = createRoute({
               heartbeat = void 0;
               if (cleanedUp) return;
               try {
-                controller.enqueue(": heartbeat\n\n");
+                controller2.enqueue(": heartbeat\n\n");
               } catch {
                 cleanup();
                 return;
@@ -281,13 +284,13 @@ var STREAM_HARNESS_SESSION_ROUTE = createRoute({
           unsubscribe = session.subscribe((event) => {
             if (cleanedUp) return;
             try {
-              controller.enqueue(event);
+              controller2.enqueue(event);
               scheduleHeartbeat();
             } catch {
               cleanup();
             }
           });
-          const abortCleanup = () => cleanup(controller);
+          const abortCleanup = () => cleanup(controller2);
           abortSignal?.addEventListener("abort", abortCleanup, { once: true });
           scheduleHeartbeat();
         },
@@ -296,215 +299,215 @@ var STREAM_HARNESS_SESSION_ROUTE = createRoute({
         }
       });
     } catch (error) {
-      return handleError(error, "error streaming harness session");
+      return handleError(error, "error streaming controller session");
     }
   }
 });
-var SEND_HARNESS_MESSAGE_ROUTE = createRoute({
+var SEND_AGENT_CONTROLLER_MESSAGE_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/messages",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/messages",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: sendMessageBodySchema,
   responseSchema: ackResponseSchema,
-  summary: "Send a message to a harness session",
+  summary: "Send a message to a controller session",
   description: "Sends a user message to the session. The reply streams as events on the session\u2019s SSE stream.",
-  tags: ["Harness", "Streaming"],
+  tags: ["AgentController", "Streaming"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, message }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, message }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       void session.sendMessage({ content: message });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error sending harness message");
+      return handleError(error, "error sending controller message");
     }
   }
 });
-var ABORT_HARNESS_SESSION_ROUTE = createRoute({
+var ABORT_AGENT_CONTROLLER_SESSION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/abort",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/abort",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: ackResponseSchema,
-  summary: "Abort a harness session run",
+  summary: "Abort a controller session run",
   description: "Aborts the in-flight run for the session, if any.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       session.abort();
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error aborting harness session");
+      return handleError(error, "error aborting controller session");
     }
   }
 });
-var HARNESS_TOOL_APPROVAL_ROUTE = createRoute({
+var AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/tool-approval",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/tool-approval",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: toolApprovalBodySchema,
   responseSchema: ackResponseSchema,
-  summary: "Respond to a harness tool approval",
+  summary: "Respond to a controller tool approval",
   description: "Approves or declines a pending tool call surfaced by the session.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, toolCallId, approved }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, toolCallId, approved }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       session.respondToToolApproval({ toolCallId, decision: approved ? "approve" : "decline" });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error responding to harness tool approval");
+      return handleError(error, "error responding to controller tool approval");
     }
   }
 });
-var HARNESS_TOOL_SUSPENSION_ROUTE = createRoute({
+var AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/tool-suspension",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/tool-suspension",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: toolSuspensionBodySchema,
   responseSchema: ackResponseSchema,
-  summary: "Respond to a suspended harness tool",
+  summary: "Respond to a suspended controller tool",
   description: "Resumes a suspended interactive tool (ask_user, request_access, submit_plan) with the provided resume data.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, toolCallId, resumeData }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, toolCallId, resumeData }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.respondToToolSuspension({ toolCallId, resumeData });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error responding to harness tool suspension");
+      return handleError(error, "error responding to controller tool suspension");
     }
   }
 });
-var STEER_HARNESS_SESSION_ROUTE = createRoute({
+var STEER_AGENT_CONTROLLER_SESSION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/steer",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/steer",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: steerBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Steer the in-flight run",
   description: "Injects a message into the running turn (interjection) without starting a new run.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, message }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, message }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       void session.steer({ content: message });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error steering harness session");
+      return handleError(error, "error steering controller session");
     }
   }
 });
-var SWITCH_HARNESS_MODE_ROUTE = createRoute({
+var SWITCH_AGENT_CONTROLLER_MODE_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/mode",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/mode",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: switchModeBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Switch the session mode",
   description: "Switches the active mode (e.g. build, plan) for the session.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, modeId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, modeId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.mode.switch({ modeId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error switching harness mode");
+      return handleError(error, "error switching controller mode");
     }
   }
 });
-var SWITCH_HARNESS_MODEL_ROUTE = createRoute({
+var SWITCH_AGENT_CONTROLLER_MODEL_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/model",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/model",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: switchModelBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Switch the session model",
   description: "Switches the model for the session, scoped to the thread by default.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, modelId, scope, modeId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, modelId, scope, modeId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.model.switch({ modelId, scope, modeId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error switching harness model");
+      return handleError(error, "error switching controller model");
     }
   }
 });
-var SWITCH_HARNESS_THREAD_ROUTE = createRoute({
+var SWITCH_AGENT_CONTROLLER_THREAD_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/thread",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/thread",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: switchThreadBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Switch the session thread",
   description: "Switches the session to an existing thread (rebinding its stream and state).",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, threadId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, threadId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.thread.switch({ threadId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error switching harness thread");
+      return handleError(error, "error switching controller thread");
     }
   }
 });
-var GET_HARNESS_SESSION_STATE_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId",
+  path: "/agent-controller/:controllerId/sessions/:resourceId",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: sessionStateResponseSchema,
   summary: "Get session state",
   description: "Returns the current mode, model, and thread for the session (for initial UI hydration).",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const ds = session.displayState.get();
       const om = ds.omProgress;
       const reflectionSavings = om.buffered.reflection.inputObservationTokens - om.buffered.reflection.observationTokens;
       const st = session.state.get();
       const oneOf = (value, allowed, fallback) => allowed.includes(value) ? value : fallback;
       return {
-        harnessId,
+        controllerId,
         resourceId,
         threadId: session.thread.getId() ?? void 0,
         modeId: session.mode.get(),
@@ -529,48 +532,48 @@ var GET_HARNESS_SESSION_STATE_ROUTE = createRoute({
         }
       };
     } catch (error) {
-      return handleError(error, "error reading harness session state");
+      return handleError(error, "error reading controller session state");
     }
   }
 });
-var LIST_HARNESS_MODES_ROUTE = createRoute({
+var LIST_AGENT_CONTROLLER_MODES_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/modes",
+  path: "/agent-controller/:controllerId/modes",
   responseType: "json",
-  pathParamSchema: harnessIdPathParams,
+  pathParamSchema: controllerIdPathParams,
   responseSchema: listModesResponseSchema,
-  summary: "List harness modes",
-  description: "Lists the modes configured on the harness (e.g. build, plan).",
-  tags: ["Harness"],
+  summary: "List controller modes",
+  description: "Lists the modes configured on the controller (e.g. build, plan).",
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
       return {
-        modes: harness.listModes().map((mode) => ({ id: mode.id, name: mode.name }))
+        modes: controller.listModes().map((mode) => ({ id: mode.id, name: mode.name }))
       };
     } catch (error) {
-      return handleError(error, "error listing harness modes");
+      return handleError(error, "error listing controller modes");
     }
   }
 });
-var LIST_HARNESS_THREADS_ROUTE = createRoute({
+var LIST_AGENT_CONTROLLER_THREADS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/threads",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   queryParamSchema: listThreadsQuerySchema,
   responseSchema: listThreadsResponseSchema,
   summary: "List session threads",
   description: "Lists the threads for the session\u2019s resource, most-recently-updated first. Pass `limit` to return only the newest N (e.g. for a sidebar). Pass `tags` (a JSON-encoded object) to scope the list to threads matching every tag \u2014 e.g. `{ projectPath }` so git worktrees sharing a resourceId each see only their own threads.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId, limit, tags }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId, limit, tags }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const threads = await session.thread.list();
       const getTags = (t) => {
         const metadata = t.metadata ?? {};
@@ -601,13 +604,13 @@ var LIST_HARNESS_THREADS_ROUTE = createRoute({
         })
       };
     } catch (error) {
-      return handleError(error, "error listing harness threads");
+      return handleError(error, "error listing controller threads");
     }
   }
 });
-var SEND_HARNESS_NOTIFICATION_ROUTE = createRoute({
+var SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/notifications",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/notifications",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: sendNotificationBodySchema,
@@ -619,12 +622,12 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = createRoute({
   }),
   summary: "Send a notification signal to a session",
   description: "Delivers a notification to the session\u2019s current agent/thread. The agent\u2019s delivery policy determines whether the notification wakes an idle thread, is summarised, or is persisted for later.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
+  requiresPermission: "agent-controller:execute",
   handler: async ({
     mastra,
-    harnessId,
+    controllerId,
     resourceId,
     source,
     kind,
@@ -638,8 +641,8 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = createRoute({
     metadata
   }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const result = await session.sendNotificationSignal({
         source,
         kind,
@@ -659,26 +662,26 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = createRoute({
         runId: result.runId
       };
     } catch (error) {
-      return handleError(error, "error sending harness notification");
+      return handleError(error, "error sending controller notification");
     }
   }
 });
-var CREATE_HARNESS_THREAD_ROUTE = createRoute({
+var CREATE_AGENT_CONTROLLER_THREAD_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/threads",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: createThreadBodySchema,
   responseSchema: threadResponseSchema,
   summary: "Create a new thread",
   description: "Creates a new thread in the session (unbinds the previous thread, binds the new one).",
-  tags: ["Harness", "Threads"],
+  tags: ["AgentController", "Threads"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, title }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, title }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const thread = await session.thread.create({ title });
       return {
         id: thread.id,
@@ -688,74 +691,74 @@ var CREATE_HARNESS_THREAD_ROUTE = createRoute({
         updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
       };
     } catch (error) {
-      return handleError(error, "error creating harness thread");
+      return handleError(error, "error creating controller thread");
     }
   }
 });
-var DELETE_HARNESS_THREAD_ROUTE = createRoute({
+var DELETE_AGENT_CONTROLLER_THREAD_ROUTE = createRoute({
   method: "DELETE",
-  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId",
   responseType: "json",
   pathParamSchema: threadPathParams,
   responseSchema: ackResponseSchema,
   summary: "Delete a thread",
   description: "Deletes a thread. If the deleted thread is the active one, the session is unbound.",
-  tags: ["Harness", "Threads"],
+  tags: ["AgentController", "Threads"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, threadId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, threadId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.thread.delete({ threadId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error deleting harness thread");
+      return handleError(error, "error deleting controller thread");
     }
   }
 });
-var RENAME_HARNESS_THREAD_ROUTE = createRoute({
+var RENAME_AGENT_CONTROLLER_THREAD_ROUTE = createRoute({
   method: "PUT",
-  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId",
   responseType: "json",
   pathParamSchema: threadPathParams,
   bodySchema: renameThreadBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Rename a thread",
   description: "Renames the specified thread.",
-  tags: ["Harness", "Threads"],
+  tags: ["AgentController", "Threads"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, threadId, title }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, threadId, title }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       if (session.thread.getId() !== threadId) {
         await session.thread.switch({ threadId });
       }
       await session.thread.rename({ title });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error renaming harness thread");
+      return handleError(error, "error renaming controller thread");
     }
   }
 });
-var CLONE_HARNESS_THREAD_ROUTE = createRoute({
+var CLONE_AGENT_CONTROLLER_THREAD_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/threads/clone",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads/clone",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: cloneThreadBodySchema,
   responseSchema: threadResponseSchema,
   summary: "Clone a thread",
   description: "Clones a thread (and its messages). The session binds to the new clone.",
-  tags: ["Harness", "Threads"],
+  tags: ["AgentController", "Threads"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, sourceThreadId, title }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, sourceThreadId, title }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const thread = await session.thread.clone({ sourceThreadId, title });
       return {
         id: thread.id,
@@ -765,26 +768,26 @@ var CLONE_HARNESS_THREAD_ROUTE = createRoute({
         updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
       };
     } catch (error) {
-      return handleError(error, "error cloning harness thread");
+      return handleError(error, "error cloning controller thread");
     }
   }
 });
-var LIST_HARNESS_THREAD_MESSAGES_ROUTE = createRoute({
+var LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId/messages",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId/messages",
   responseType: "json",
   pathParamSchema: threadPathParams,
   queryParamSchema: listMessagesQuerySchema,
   responseSchema: listMessagesResponseSchema,
   summary: "List thread messages",
   description: "Lists messages for a specific thread. Returns most recent messages first.",
-  tags: ["Harness", "Threads"],
+  tags: ["AgentController", "Threads"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId, threadId, limit }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId, threadId, limit }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const messages = await session.thread.listMessages({ threadId, limit });
       return {
         messages: messages.map((m) => ({
@@ -795,49 +798,49 @@ var LIST_HARNESS_THREAD_MESSAGES_ROUTE = createRoute({
         }))
       };
     } catch (error) {
-      return handleError(error, "error listing harness thread messages");
+      return handleError(error, "error listing controller thread messages");
     }
   }
 });
-var FOLLOW_UP_HARNESS_SESSION_ROUTE = createRoute({
+var FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/follow-up",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/follow-up",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: followUpBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Queue a follow-up message",
   description: "Queues a follow-up message. If the session is idle it sends immediately; if a run is active it queues for after completion.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, message }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, message }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       void session.followUp({ content: message });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error queuing harness follow-up");
+      return handleError(error, "error queuing controller follow-up");
     }
   }
 });
-var LIST_HARNESS_MODELS_ROUTE = createRoute({
+var LIST_AGENT_CONTROLLER_MODELS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/models",
+  path: "/agent-controller/:controllerId/models",
   responseType: "json",
-  pathParamSchema: harnessIdPathParams,
+  pathParamSchema: controllerIdPathParams,
   responseSchema: listModelsResponseSchema,
   summary: "List available models",
-  description: "Lists all models available on this harness (with auth status and use counts).",
-  tags: ["Harness"],
+  description: "Lists all models available on this controller (with auth status and use counts).",
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      await harness.init();
-      const models = await harness.listAvailableModels();
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      await controller.init();
+      const models = await controller.listAvailableModels();
       return {
         models: models.map((m) => ({
           id: m.id,
@@ -848,98 +851,98 @@ var LIST_HARNESS_MODELS_ROUTE = createRoute({
         }))
       };
     } catch (error) {
-      return handleError(error, "error listing harness models");
+      return handleError(error, "error listing controller models");
     }
   }
 });
-var GET_HARNESS_WORKSPACE_STATUS_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/workspace",
+  path: "/agent-controller/:controllerId/workspace",
   responseType: "json",
-  pathParamSchema: harnessIdPathParams,
+  pathParamSchema: controllerIdPathParams,
   responseSchema: workspaceStatusResponseSchema,
   summary: "Get workspace status",
-  description: "Returns whether the harness has a workspace configured and whether it is ready.",
-  tags: ["Harness"],
+  description: "Returns whether the controller has a workspace configured and whether it is ready.",
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      await harness.init();
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      await controller.init();
       return {
-        hasWorkspace: harness.hasWorkspace(),
-        isReady: harness.isWorkspaceReady()
+        hasWorkspace: controller.hasWorkspace(),
+        isReady: controller.isWorkspaceReady()
       };
     } catch (error) {
-      return handleError(error, "error reading harness workspace status");
+      return handleError(error, "error reading controller workspace status");
     }
   }
 });
-var GET_HARNESS_OM_RECORD_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_OM_RECORD_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/om",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/om",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: omRecordResponseSchema,
   summary: "Get observational memory record",
   description: "Returns the current observational memory record for the session\u2019s thread/resource.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
-      const record = await harness.getObservationalMemoryRecord(session);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
+      const record = await controller.getObservationalMemoryRecord(session);
       return { record: record ?? void 0 };
     } catch (error) {
-      return handleError(error, "error reading harness OM record");
+      return handleError(error, "error reading controller OM record");
     }
   }
 });
-var SET_HARNESS_RESOURCE_ID_ROUTE = createRoute({
+var SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/resource",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/resource",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: z.object({ newResourceId: z.string() }),
   responseSchema: ackResponseSchema,
   summary: "Change the session resource ID",
   description: "Updates the session\u2019s resource identity (e.g. when a user logs in).",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, newResourceId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, newResourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
-      await harness.setResourceId(session, { resourceId: newResourceId });
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
+      await controller.setResourceId(session, { resourceId: newResourceId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error setting harness resource ID");
+      return handleError(error, "error setting controller resource ID");
     }
   }
 });
-var GET_HARNESS_RESOURCE_IDS_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/resources",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/resources",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: z.object({ resourceIds: z.array(z.string()) }),
   summary: "Get known resource IDs",
   description: "Lists the resource IDs known to this session (from threads).",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
-      const resourceIds = await harness.getKnownResourceIds(session);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
+      const resourceIds = await controller.getKnownResourceIds(session);
       return { resourceIds };
     } catch (error) {
-      return handleError(error, "error listing harness resource IDs");
+      return handleError(error, "error listing controller resource IDs");
     }
   }
 });
@@ -965,53 +968,53 @@ var goalRecordSchema = z.object({
   pausedReason: z.string().optional()
 });
 var goalResponseSchema = z.object({ goal: goalRecordSchema.optional() });
-function getAgentForSession(harness, session) {
-  return harness.getCurrentAgent(session);
+function getAgentForSession(controller, session) {
+  return controller.getCurrentAgent(session);
 }
-var GET_HARNESS_GOAL_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_GOAL_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/goal",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: goalResponseSchema,
   summary: "Get the current goal",
   description: "Returns the active/paused/done goal objective for the session\u2019s thread, if any.",
-  tags: ["Harness", "Goals"],
+  tags: ["AgentController", "Goals"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const threadId = session.thread.getId();
       if (!threadId) return { goal: void 0 };
-      const agent = getAgentForSession(harness, session);
+      const agent = getAgentForSession(controller, session);
       const record = await agent.getObjective({ threadId });
       return { goal: record ?? void 0 };
     } catch (error) {
-      return handleError(error, "error reading harness goal");
+      return handleError(error, "error reading controller goal");
     }
   }
 });
-var SET_HARNESS_GOAL_ROUTE = createRoute({
+var SET_AGENT_CONTROLLER_GOAL_ROUTE = createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/goal",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: setGoalBodySchema,
   responseSchema: goalResponseSchema,
   summary: "Set a goal",
   description: "Sets a new objective for the session\u2019s thread. The agent\u2019s in-loop goal judge evaluates progress after each turn.",
-  tags: ["Harness", "Goals"],
+  tags: ["AgentController", "Goals"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, objective, judgeModelId, maxRuns }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, objective, judgeModelId, maxRuns }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const threadId = session.thread.getId();
       if (!threadId) throw new HTTPException(400, { message: "session has no active thread" });
-      const agent = getAgentForSession(harness, session);
+      const agent = getAgentForSession(controller, session);
       const record = await agent.setObjective(objective, {
         threadId,
         resourceId: session.identity.getResourceId(),
@@ -1020,29 +1023,29 @@ var SET_HARNESS_GOAL_ROUTE = createRoute({
       });
       return { goal: record ?? void 0 };
     } catch (error) {
-      return handleError(error, "error setting harness goal");
+      return handleError(error, "error setting controller goal");
     }
   }
 });
-var UPDATE_HARNESS_GOAL_ROUTE = createRoute({
+var UPDATE_AGENT_CONTROLLER_GOAL_ROUTE = createRoute({
   method: "PUT",
-  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/goal",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: updateGoalBodySchema,
   responseSchema: goalResponseSchema,
   summary: "Update goal options",
   description: "Updates the judge model, max runs, or status of the active goal. No-op when no goal is set.",
-  tags: ["Harness", "Goals"],
+  tags: ["AgentController", "Goals"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, judgeModelId, maxRuns, status }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, judgeModelId, maxRuns, status }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const threadId = session.thread.getId();
       if (!threadId) throw new HTTPException(400, { message: "session has no active thread" });
-      const agent = getAgentForSession(harness, session);
+      const agent = getAgentForSession(controller, session);
       const record = await agent.updateObjectiveOptions({
         threadId,
         ...judgeModelId !== void 0 ? { judgeModelId } : {},
@@ -1051,131 +1054,131 @@ var UPDATE_HARNESS_GOAL_ROUTE = createRoute({
       });
       return { goal: record ?? void 0 };
     } catch (error) {
-      return handleError(error, "error updating harness goal");
+      return handleError(error, "error updating controller goal");
     }
   }
 });
-var CLEAR_HARNESS_GOAL_ROUTE = createRoute({
+var CLEAR_AGENT_CONTROLLER_GOAL_ROUTE = createRoute({
   method: "DELETE",
-  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/goal",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: ackResponseSchema,
   summary: "Clear the goal",
   description: "Removes the active goal from the session\u2019s thread.",
-  tags: ["Harness", "Goals"],
+  tags: ["AgentController", "Goals"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const threadId = session.thread.getId();
       if (!threadId) throw new HTTPException(400, { message: "session has no active thread" });
-      const agent = getAgentForSession(harness, session);
+      const agent = getAgentForSession(controller, session);
       await agent.clearObjective({ threadId });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error clearing harness goal");
+      return handleError(error, "error clearing controller goal");
     }
   }
 });
-var GET_HARNESS_PERMISSIONS_ROUTE = createRoute({
+var GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE = createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/permissions",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/permissions",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: permissionRulesResponseSchema,
   summary: "Get permission rules",
   description: "Returns the current permission rules (per-category and per-tool policies) for the session.",
-  tags: ["Harness", "Permissions"],
+  tags: ["AgentController", "Permissions"],
   requiresAuth: true,
-  requiresPermission: "harness:read",
-  handler: async ({ mastra, harnessId, resourceId }) => {
+  requiresPermission: "agent-controller:read",
+  handler: async ({ mastra, controllerId, resourceId }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       const rules = session.permissions.getRules();
       return {
         categories: rules.categories,
         tools: rules.tools
       };
     } catch (error) {
-      return handleError(error, "error getting harness permissions");
+      return handleError(error, "error getting controller permissions");
     }
   }
 });
-var SET_HARNESS_CATEGORY_PERMISSION_ROUTE = createRoute({
+var SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE = createRoute({
   method: "PUT",
-  path: "/harness/:harnessId/sessions/:resourceId/permissions/category",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/permissions/category",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: setCategoryPermissionBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Set permission for a tool category",
   description: "Sets the approval policy (allow/ask/deny) for all tools in a category.",
-  tags: ["Harness", "Permissions"],
+  tags: ["AgentController", "Permissions"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, category, policy }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, category, policy }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.permissions.setForCategory({ category, policy });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error setting harness category permission");
+      return handleError(error, "error setting controller category permission");
     }
   }
 });
-var SET_HARNESS_TOOL_PERMISSION_ROUTE = createRoute({
+var SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE = createRoute({
   method: "PUT",
-  path: "/harness/:harnessId/sessions/:resourceId/permissions/tool",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/permissions/tool",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: setToolPermissionBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Set permission for a specific tool",
   description: "Sets the approval policy (allow/ask/deny) for a specific tool by name. Per-tool overrides take precedence over category policies.",
-  tags: ["Harness", "Permissions"],
+  tags: ["AgentController", "Permissions"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, toolName, policy }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, toolName, policy }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.permissions.setForTool({ toolName, policy });
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error setting harness tool permission");
+      return handleError(error, "error setting controller tool permission");
     }
   }
 });
 var setSessionStateBodySchema = z.object({ state: z.record(z.string(), z.unknown()) });
-var SET_HARNESS_SESSION_STATE_ROUTE = createRoute({
+var SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = createRoute({
   method: "PUT",
-  path: "/harness/:harnessId/sessions/:resourceId/state",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/state",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: setSessionStateBodySchema,
   responseSchema: ackResponseSchema,
   summary: "Set session state",
   description: "Merges the provided key-value pairs into the session state. Existing keys not in the payload are preserved.",
-  tags: ["Harness"],
+  tags: ["AgentController"],
   requiresAuth: true,
-  requiresPermission: "harness:execute",
-  handler: async ({ mastra, harnessId, resourceId, state }) => {
+  requiresPermission: "agent-controller:execute",
+  handler: async ({ mastra, controllerId, resourceId, state }) => {
     try {
-      const harness = getHarnessOrThrow(mastra, harnessId);
-      const session = await getSession(harness, resourceId);
+      const controller = getAgentControllerOrThrow(mastra, controllerId);
+      const session = await getSession(controller, resourceId);
       await session.state.set(state);
       return { ok: true };
     } catch (error) {
-      return handleError(error, "error setting harness session state");
+      return handleError(error, "error setting controller session state");
     }
   }
 });
 
-export { ABORT_HARNESS_SESSION_ROUTE, CLEAR_HARNESS_GOAL_ROUTE, CLONE_HARNESS_THREAD_ROUTE, CREATE_HARNESS_SESSION_ROUTE, CREATE_HARNESS_THREAD_ROUTE, DELETE_HARNESS_THREAD_ROUTE, FOLLOW_UP_HARNESS_SESSION_ROUTE, GET_HARNESS_GOAL_ROUTE, GET_HARNESS_OM_RECORD_ROUTE, GET_HARNESS_PERMISSIONS_ROUTE, GET_HARNESS_RESOURCE_IDS_ROUTE, GET_HARNESS_SESSION_STATE_ROUTE, GET_HARNESS_WORKSPACE_STATUS_ROUTE, HARNESS_TOOL_APPROVAL_ROUTE, HARNESS_TOOL_SUSPENSION_ROUTE, LIST_HARNESSES_ROUTE, LIST_HARNESS_MODELS_ROUTE, LIST_HARNESS_MODES_ROUTE, LIST_HARNESS_THREADS_ROUTE, LIST_HARNESS_THREAD_MESSAGES_ROUTE, RENAME_HARNESS_THREAD_ROUTE, SEND_HARNESS_MESSAGE_ROUTE, SEND_HARNESS_NOTIFICATION_ROUTE, SET_HARNESS_CATEGORY_PERMISSION_ROUTE, SET_HARNESS_GOAL_ROUTE, SET_HARNESS_RESOURCE_ID_ROUTE, SET_HARNESS_SESSION_STATE_ROUTE, SET_HARNESS_TOOL_PERMISSION_ROUTE, STEER_HARNESS_SESSION_ROUTE, STREAM_HARNESS_SESSION_ROUTE, SWITCH_HARNESS_MODEL_ROUTE, SWITCH_HARNESS_MODE_ROUTE, SWITCH_HARNESS_THREAD_ROUTE, UPDATE_HARNESS_GOAL_ROUTE };
-//# sourceMappingURL=chunk-3WE5YAL5.js.map
-//# sourceMappingURL=chunk-3WE5YAL5.js.map
+export { ABORT_AGENT_CONTROLLER_SESSION_ROUTE, AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE, AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE, CLEAR_AGENT_CONTROLLER_GOAL_ROUTE, CLONE_AGENT_CONTROLLER_THREAD_ROUTE, CREATE_AGENT_CONTROLLER_SESSION_ROUTE, CREATE_AGENT_CONTROLLER_THREAD_ROUTE, DELETE_AGENT_CONTROLLER_THREAD_ROUTE, FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE, GET_AGENT_CONTROLLER_GOAL_ROUTE, GET_AGENT_CONTROLLER_OM_RECORD_ROUTE, GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE, GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE, GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE, GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE, LIST_AGENT_CONTROLLERS_ROUTE, LIST_AGENT_CONTROLLER_MODELS_ROUTE, LIST_AGENT_CONTROLLER_MODES_ROUTE, LIST_AGENT_CONTROLLER_THREADS_ROUTE, LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE, RENAME_AGENT_CONTROLLER_THREAD_ROUTE, SEND_AGENT_CONTROLLER_MESSAGE_ROUTE, SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE, SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE, SET_AGENT_CONTROLLER_GOAL_ROUTE, SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE, SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE, SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE, STEER_AGENT_CONTROLLER_SESSION_ROUTE, STREAM_AGENT_CONTROLLER_SESSION_ROUTE, SWITCH_AGENT_CONTROLLER_MODEL_ROUTE, SWITCH_AGENT_CONTROLLER_MODE_ROUTE, SWITCH_AGENT_CONTROLLER_THREAD_ROUTE, UPDATE_AGENT_CONTROLLER_GOAL_ROUTE };
+//# sourceMappingURL=chunk-RLAOC73C.js.map
+//# sourceMappingURL=chunk-RLAOC73C.js.map