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

package/dist/{chunk-4LQSGGSH.cjs → chunk-UGI45E76.cjs}

@@ -8,19 +8,19 @@ var v4 = require('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 chunk64ITUOXI_cjs.HTTPException(404, { message: `harness "${harnessId}" not found` });
+function getAgentControllerOrThrow(mastra, controllerId) {
+  const controller = mastra.getAgentController?.(controllerId);
+  if (!controller) {
+    throw new chunk64ITUOXI_cjs.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 = v4.z.object({ harnessId: v4.z.string() });
-var sessionPathParams = v4.z.object({ harnessId: v4.z.string(), resourceId: v4.z.string() });
+var controllerIdPathParams = v4.z.object({ controllerId: v4.z.string() });
+var sessionPathParams = v4.z.object({ controllerId: v4.z.string(), resourceId: v4.z.string() });
 var createSessionBodySchema = v4.z.object({
   resourceId: v4.z.string(),
   tags: v4.z.record(v4.z.string(), v4.z.string()).optional()
@@ -47,7 +47,7 @@ var switchModelBodySchema = v4.z.object({
 var switchThreadBodySchema = v4.z.object({ threadId: v4.z.string() });
 var createThreadBodySchema = v4.z.object({ title: v4.z.string().optional() });
 var renameThreadBodySchema = v4.z.object({ title: v4.z.string() });
-var threadPathParams = v4.z.object({ harnessId: v4.z.string(), resourceId: v4.z.string(), threadId: v4.z.string() });
+var threadPathParams = v4.z.object({ controllerId: v4.z.string(), resourceId: v4.z.string(), threadId: v4.z.string() });
 var cloneThreadBodySchema = v4.z.object({
   sourceThreadId: v4.z.string().optional(),
   title: v4.z.string().optional()
@@ -77,11 +77,11 @@ var sendNotificationBodySchema = v4.z.object({
   attributes: v4.z.record(v4.z.string(), v4.z.unknown()).optional(),
   metadata: v4.z.record(v4.z.string(), v4.z.unknown()).optional()
 });
-var listHarnessesResponseSchema = v4.z.object({
-  harnesses: v4.z.array(v4.z.object({ id: v4.z.string() }))
+var listAgentControllersResponseSchema = v4.z.object({
+  agentControllers: v4.z.array(v4.z.object({ id: v4.z.string() }))
 });
 var createSessionResponseSchema = v4.z.object({
-  harnessId: v4.z.string(),
+  controllerId: v4.z.string(),
   resourceId: v4.z.string(),
   threadId: v4.z.string().optional()
 });
@@ -106,7 +106,7 @@ var sessionSettingsSchema = v4.z.object({
   smartEditing: v4.z.boolean()
 });
 var sessionStateResponseSchema = v4.z.object({
-  harnessId: v4.z.string(),
+  controllerId: v4.z.string(),
   resourceId: v4.z.string(),
   threadId: v4.z.string().optional(),
   modeId: v4.z.string(),
@@ -181,67 +181,70 @@ var setToolPermissionBodySchema = v4.z.object({
   toolName: v4.z.string(),
   policy: permissionPolicyEnum
 });
-var LIST_HARNESSES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var LIST_AGENT_CONTROLLERS_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error listing harnesses");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing agent controllers");
     }
   }
 });
-var CREATE_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var CREATE_AGENT_CONTROLLER_SESSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error creating harness session");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error creating controller session");
     }
   }
 });
-var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var STREAM_AGENT_CONTROLLER_SESSION_ROUTE = chunkG54X6VE6_cjs.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;
@@ -251,20 +254,20 @@ var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.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();
@@ -272,7 +275,7 @@ var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
               heartbeat = void 0;
               if (cleanedUp) return;
               try {
-                controller.enqueue(": heartbeat\n\n");
+                controller2.enqueue(": heartbeat\n\n");
               } catch {
                 cleanup();
                 return;
@@ -283,13 +286,13 @@ var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.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();
         },
@@ -298,215 +301,215 @@ var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
         }
       });
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error streaming harness session");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error streaming controller session");
     }
   }
 });
-var SEND_HARNESS_MESSAGE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SEND_AGENT_CONTROLLER_MESSAGE_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error sending harness message");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error sending controller message");
     }
   }
 });
-var ABORT_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var ABORT_AGENT_CONTROLLER_SESSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error aborting harness session");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error aborting controller session");
     }
   }
 });
-var HARNESS_TOOL_APPROVAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error responding to harness tool approval");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error responding to controller tool approval");
     }
   }
 });
-var HARNESS_TOOL_SUSPENSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error responding to harness tool suspension");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error responding to controller tool suspension");
     }
   }
 });
-var STEER_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var STEER_AGENT_CONTROLLER_SESSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error steering harness session");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error steering controller session");
     }
   }
 });
-var SWITCH_HARNESS_MODE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SWITCH_AGENT_CONTROLLER_MODE_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error switching harness mode");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching controller mode");
     }
   }
 });
-var SWITCH_HARNESS_MODEL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SWITCH_AGENT_CONTROLLER_MODEL_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error switching harness model");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching controller model");
     }
   }
 });
-var SWITCH_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SWITCH_AGENT_CONTROLLER_THREAD_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error switching harness thread");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching controller thread");
     }
   }
 });
-var GET_HARNESS_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.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(),
@@ -531,48 +534,48 @@ var GET_HARNESS_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.createRoute({
         }
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error reading harness session state");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading controller session state");
     }
   }
 });
-var LIST_HARNESS_MODES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var LIST_AGENT_CONTROLLER_MODES_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error listing harness modes");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing controller modes");
     }
   }
 });
-var LIST_HARNESS_THREADS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var LIST_AGENT_CONTROLLER_THREADS_ROUTE = chunkG54X6VE6_cjs.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 ?? {};
@@ -603,13 +606,13 @@ var LIST_HARNESS_THREADS_ROUTE = chunkG54X6VE6_cjs.createRoute({
         })
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness threads");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing controller threads");
     }
   }
 });
-var SEND_HARNESS_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/notifications",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/notifications",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: sendNotificationBodySchema,
@@ -621,12 +624,12 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.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,
@@ -640,8 +643,8 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.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,
@@ -661,26 +664,26 @@ var SEND_HARNESS_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.createRoute({
         runId: result.runId
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error sending harness notification");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error sending controller notification");
     }
   }
 });
-var CREATE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var CREATE_AGENT_CONTROLLER_THREAD_ROUTE = chunkG54X6VE6_cjs.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,
@@ -690,74 +693,74 @@ var CREATE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
         updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error creating harness thread");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error creating controller thread");
     }
   }
 });
-var DELETE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var DELETE_AGENT_CONTROLLER_THREAD_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error deleting harness thread");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error deleting controller thread");
     }
   }
 });
-var RENAME_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var RENAME_AGENT_CONTROLLER_THREAD_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error renaming harness thread");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error renaming controller thread");
     }
   }
 });
-var CLONE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var CLONE_AGENT_CONTROLLER_THREAD_ROUTE = chunkG54X6VE6_cjs.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,
@@ -767,26 +770,26 @@ var CLONE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
         updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error cloning harness thread");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error cloning controller thread");
     }
   }
 });
-var LIST_HARNESS_THREAD_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE = chunkG54X6VE6_cjs.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) => ({
@@ -797,49 +800,49 @@ var LIST_HARNESS_THREAD_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
         }))
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness thread messages");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing controller thread messages");
     }
   }
 });
-var FOLLOW_UP_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error queuing harness follow-up");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error queuing controller follow-up");
     }
   }
 });
-var LIST_HARNESS_MODELS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var LIST_AGENT_CONTROLLER_MODELS_ROUTE = chunkG54X6VE6_cjs.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,
@@ -850,98 +853,98 @@ var LIST_HARNESS_MODELS_ROUTE = chunkG54X6VE6_cjs.createRoute({
         }))
       };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness models");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing controller models");
     }
   }
 });
-var GET_HARNESS_WORKSPACE_STATUS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error reading harness workspace status");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading controller workspace status");
     }
   }
 });
-var GET_HARNESS_OM_RECORD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_OM_RECORD_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error reading harness OM record");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading controller OM record");
     }
   }
 });
-var SET_HARNESS_RESOURCE_ID_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE = chunkG54X6VE6_cjs.createRoute({
   method: "POST",
-  path: "/harness/:harnessId/sessions/:resourceId/resource",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/resource",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   bodySchema: v4.z.object({ newResourceId: v4.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 chunkZ7LCIYK7_cjs.handleError(error, "error setting harness resource ID");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting controller resource ID");
     }
   }
 });
-var GET_HARNESS_RESOURCE_IDS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE = chunkG54X6VE6_cjs.createRoute({
   method: "GET",
-  path: "/harness/:harnessId/sessions/:resourceId/resources",
+  path: "/agent-controller/:controllerId/sessions/:resourceId/resources",
   responseType: "json",
   pathParamSchema: sessionPathParams,
   responseSchema: v4.z.object({ resourceIds: v4.z.array(v4.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 chunkZ7LCIYK7_cjs.handleError(error, "error listing harness resource IDs");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing controller resource IDs");
     }
   }
 });
@@ -967,53 +970,53 @@ var goalRecordSchema = v4.z.object({
   pausedReason: v4.z.string().optional()
 });
 var goalResponseSchema = v4.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 = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_GOAL_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error reading harness goal");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading controller goal");
     }
   }
 });
-var SET_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SET_AGENT_CONTROLLER_GOAL_ROUTE = chunkG54X6VE6_cjs.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 chunk64ITUOXI_cjs.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(),
@@ -1022,29 +1025,29 @@ var SET_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
       });
       return { goal: record ?? void 0 };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness goal");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting controller goal");
     }
   }
 });
-var UPDATE_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var UPDATE_AGENT_CONTROLLER_GOAL_ROUTE = chunkG54X6VE6_cjs.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 chunk64ITUOXI_cjs.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 } : {},
@@ -1053,164 +1056,164 @@ var UPDATE_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
       });
       return { goal: record ?? void 0 };
     } catch (error) {
-      return chunkZ7LCIYK7_cjs.handleError(error, "error updating harness goal");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error updating controller goal");
     }
   }
 });
-var CLEAR_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var CLEAR_AGENT_CONTROLLER_GOAL_ROUTE = chunkG54X6VE6_cjs.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 chunk64ITUOXI_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error clearing harness goal");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error clearing controller goal");
     }
   }
 });
-var GET_HARNESS_PERMISSIONS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error getting harness permissions");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error getting controller permissions");
     }
   }
 });
-var SET_HARNESS_CATEGORY_PERMISSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error setting harness category permission");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting controller category permission");
     }
   }
 });
-var SET_HARNESS_TOOL_PERMISSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error setting harness tool permission");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting controller tool permission");
     }
   }
 });
 var setSessionStateBodySchema = v4.z.object({ state: v4.z.record(v4.z.string(), v4.z.unknown()) });
-var SET_HARNESS_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+var SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.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 chunkZ7LCIYK7_cjs.handleError(error, "error setting harness session state");
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting controller session state");
     }
   }
 });
 
-exports.ABORT_HARNESS_SESSION_ROUTE = ABORT_HARNESS_SESSION_ROUTE;
-exports.CLEAR_HARNESS_GOAL_ROUTE = CLEAR_HARNESS_GOAL_ROUTE;
-exports.CLONE_HARNESS_THREAD_ROUTE = CLONE_HARNESS_THREAD_ROUTE;
-exports.CREATE_HARNESS_SESSION_ROUTE = CREATE_HARNESS_SESSION_ROUTE;
-exports.CREATE_HARNESS_THREAD_ROUTE = CREATE_HARNESS_THREAD_ROUTE;
-exports.DELETE_HARNESS_THREAD_ROUTE = DELETE_HARNESS_THREAD_ROUTE;
-exports.FOLLOW_UP_HARNESS_SESSION_ROUTE = FOLLOW_UP_HARNESS_SESSION_ROUTE;
-exports.GET_HARNESS_GOAL_ROUTE = GET_HARNESS_GOAL_ROUTE;
-exports.GET_HARNESS_OM_RECORD_ROUTE = GET_HARNESS_OM_RECORD_ROUTE;
-exports.GET_HARNESS_PERMISSIONS_ROUTE = GET_HARNESS_PERMISSIONS_ROUTE;
-exports.GET_HARNESS_RESOURCE_IDS_ROUTE = GET_HARNESS_RESOURCE_IDS_ROUTE;
-exports.GET_HARNESS_SESSION_STATE_ROUTE = GET_HARNESS_SESSION_STATE_ROUTE;
-exports.GET_HARNESS_WORKSPACE_STATUS_ROUTE = GET_HARNESS_WORKSPACE_STATUS_ROUTE;
-exports.HARNESS_TOOL_APPROVAL_ROUTE = HARNESS_TOOL_APPROVAL_ROUTE;
-exports.HARNESS_TOOL_SUSPENSION_ROUTE = HARNESS_TOOL_SUSPENSION_ROUTE;
-exports.LIST_HARNESSES_ROUTE = LIST_HARNESSES_ROUTE;
-exports.LIST_HARNESS_MODELS_ROUTE = LIST_HARNESS_MODELS_ROUTE;
-exports.LIST_HARNESS_MODES_ROUTE = LIST_HARNESS_MODES_ROUTE;
-exports.LIST_HARNESS_THREADS_ROUTE = LIST_HARNESS_THREADS_ROUTE;
-exports.LIST_HARNESS_THREAD_MESSAGES_ROUTE = LIST_HARNESS_THREAD_MESSAGES_ROUTE;
-exports.RENAME_HARNESS_THREAD_ROUTE = RENAME_HARNESS_THREAD_ROUTE;
-exports.SEND_HARNESS_MESSAGE_ROUTE = SEND_HARNESS_MESSAGE_ROUTE;
-exports.SEND_HARNESS_NOTIFICATION_ROUTE = SEND_HARNESS_NOTIFICATION_ROUTE;
-exports.SET_HARNESS_CATEGORY_PERMISSION_ROUTE = SET_HARNESS_CATEGORY_PERMISSION_ROUTE;
-exports.SET_HARNESS_GOAL_ROUTE = SET_HARNESS_GOAL_ROUTE;
-exports.SET_HARNESS_RESOURCE_ID_ROUTE = SET_HARNESS_RESOURCE_ID_ROUTE;
-exports.SET_HARNESS_SESSION_STATE_ROUTE = SET_HARNESS_SESSION_STATE_ROUTE;
-exports.SET_HARNESS_TOOL_PERMISSION_ROUTE = SET_HARNESS_TOOL_PERMISSION_ROUTE;
-exports.STEER_HARNESS_SESSION_ROUTE = STEER_HARNESS_SESSION_ROUTE;
-exports.STREAM_HARNESS_SESSION_ROUTE = STREAM_HARNESS_SESSION_ROUTE;
-exports.SWITCH_HARNESS_MODEL_ROUTE = SWITCH_HARNESS_MODEL_ROUTE;
-exports.SWITCH_HARNESS_MODE_ROUTE = SWITCH_HARNESS_MODE_ROUTE;
-exports.SWITCH_HARNESS_THREAD_ROUTE = SWITCH_HARNESS_THREAD_ROUTE;
-exports.UPDATE_HARNESS_GOAL_ROUTE = UPDATE_HARNESS_GOAL_ROUTE;
-//# sourceMappingURL=chunk-4LQSGGSH.cjs.map
-//# sourceMappingURL=chunk-4LQSGGSH.cjs.map
+exports.ABORT_AGENT_CONTROLLER_SESSION_ROUTE = ABORT_AGENT_CONTROLLER_SESSION_ROUTE;
+exports.AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE = AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE;
+exports.AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE = AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE;
+exports.CLEAR_AGENT_CONTROLLER_GOAL_ROUTE = CLEAR_AGENT_CONTROLLER_GOAL_ROUTE;
+exports.CLONE_AGENT_CONTROLLER_THREAD_ROUTE = CLONE_AGENT_CONTROLLER_THREAD_ROUTE;
+exports.CREATE_AGENT_CONTROLLER_SESSION_ROUTE = CREATE_AGENT_CONTROLLER_SESSION_ROUTE;
+exports.CREATE_AGENT_CONTROLLER_THREAD_ROUTE = CREATE_AGENT_CONTROLLER_THREAD_ROUTE;
+exports.DELETE_AGENT_CONTROLLER_THREAD_ROUTE = DELETE_AGENT_CONTROLLER_THREAD_ROUTE;
+exports.FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE = FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE;
+exports.GET_AGENT_CONTROLLER_GOAL_ROUTE = GET_AGENT_CONTROLLER_GOAL_ROUTE;
+exports.GET_AGENT_CONTROLLER_OM_RECORD_ROUTE = GET_AGENT_CONTROLLER_OM_RECORD_ROUTE;
+exports.GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE = GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE;
+exports.GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE = GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE;
+exports.GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE;
+exports.GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE = GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE;
+exports.LIST_AGENT_CONTROLLERS_ROUTE = LIST_AGENT_CONTROLLERS_ROUTE;
+exports.LIST_AGENT_CONTROLLER_MODELS_ROUTE = LIST_AGENT_CONTROLLER_MODELS_ROUTE;
+exports.LIST_AGENT_CONTROLLER_MODES_ROUTE = LIST_AGENT_CONTROLLER_MODES_ROUTE;
+exports.LIST_AGENT_CONTROLLER_THREADS_ROUTE = LIST_AGENT_CONTROLLER_THREADS_ROUTE;
+exports.LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE = LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE;
+exports.RENAME_AGENT_CONTROLLER_THREAD_ROUTE = RENAME_AGENT_CONTROLLER_THREAD_ROUTE;
+exports.SEND_AGENT_CONTROLLER_MESSAGE_ROUTE = SEND_AGENT_CONTROLLER_MESSAGE_ROUTE;
+exports.SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE = SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE;
+exports.SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE = SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE;
+exports.SET_AGENT_CONTROLLER_GOAL_ROUTE = SET_AGENT_CONTROLLER_GOAL_ROUTE;
+exports.SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE = SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE;
+exports.SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE;
+exports.SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE = SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE;
+exports.STEER_AGENT_CONTROLLER_SESSION_ROUTE = STEER_AGENT_CONTROLLER_SESSION_ROUTE;
+exports.STREAM_AGENT_CONTROLLER_SESSION_ROUTE = STREAM_AGENT_CONTROLLER_SESSION_ROUTE;
+exports.SWITCH_AGENT_CONTROLLER_MODEL_ROUTE = SWITCH_AGENT_CONTROLLER_MODEL_ROUTE;
+exports.SWITCH_AGENT_CONTROLLER_MODE_ROUTE = SWITCH_AGENT_CONTROLLER_MODE_ROUTE;
+exports.SWITCH_AGENT_CONTROLLER_THREAD_ROUTE = SWITCH_AGENT_CONTROLLER_THREAD_ROUTE;
+exports.UPDATE_AGENT_CONTROLLER_GOAL_ROUTE = UPDATE_AGENT_CONTROLLER_GOAL_ROUTE;
+//# sourceMappingURL=chunk-UGI45E76.cjs.map
+//# sourceMappingURL=chunk-UGI45E76.cjs.map