@opengoat/core 2026.2.14 → 2026.2.17

package/dist/core/opengoat/application/opengoat.service.js

@@ -1,18 +1,24 @@
-import { homedir } from "node:os";
-import path from "node:path";
 import { AgentManifestService } from "../../agents/application/agent-manifest.service.js";
 import { AgentService } from "../../agents/application/agent.service.js";
 import { BoardService, } from "../../boards/index.js";
 import { BootstrapService } from "../../bootstrap/application/bootstrap.service.js";
-import { DEFAULT_AGENT_ID, normalizeAgentId } from "../../domain/agent-id.js";
+import { DEFAULT_AGENT_ID, isDefaultAgentId, normalizeAgentId, } from "../../domain/agent-id.js";
 import { createNoopLogger } from "../../logging/index.js";
 import { OrchestrationService, } from "../../orchestration/index.js";
 import { ProviderService } from "../../providers/application/provider.service.js";
 import { ProviderCommandNotFoundError, createDefaultProviderRegistry, } from "../../providers/index.js";
+import { dirname, resolve as resolvePath } from "node:path";
 import { SessionService, } from "../../sessions/index.js";
 import { SkillService, } from "../../skills/index.js";
+import { assertAgentExists, buildBlockedTaskMessage, buildInactiveAgentMessage, buildNotificationSessionRef, buildPendingTaskMessage, buildReporteeStats, buildTodoTaskMessage, collectAllReportees, containsAgentNotFoundMessage, containsAlreadyExistsMessage, extractManagedSkillsDir, extractOpenClawAgents, isSpawnPermissionOrMissing, pathIsWithin, pathMatches, prepareOpenClawCommandEnv, resolveInactiveAgentNotificationTarget, resolveInactiveMinutes, resolveMaxParallelFlows, toErrorMessage, } from "./opengoat.service.helpers.js";
 const OPENCLAW_PROVIDER_ID = "openclaw";
 const OPENCLAW_DEFAULT_AGENT_ID = "main";
+const OPENCLAW_AGENT_SANDBOX_MODE = "off";
+const OPENCLAW_AGENT_TOOLS_ALLOW_ALL_JSON = "[\"*\"]";
+const OPENCLAW_OPENGOAT_PLUGIN_ID = "openclaw-plugin";
+const OPENCLAW_OPENGOAT_PLUGIN_ROOT_ID = "opengoat-plugin";
+const OPENCLAW_OPENGOAT_PLUGIN_LEGACY_PACK_ID = "openclaw-plugin-pack";
+const OPENCLAW_OPENGOAT_PLUGIN_FALLBACK_ID = "workspace";
 export class OpenGoatService {
     fileSystem;
     pathPort;
@@ -178,9 +184,10 @@ export class OpenGoatService {
         const warnings = [];
         let ceoSynced = false;
         let ceoSyncCode;
-        let ceoDescriptor = (await this.agentService.listAgents(paths)).find((agent) => agent.id === DEFAULT_AGENT_ID);
-        if (!ceoDescriptor) {
-            const created = await this.agentService.ensureAgent(paths, {
+        let localAgents = [];
+        const ceoExists = (await this.agentService.listAgents(paths)).some((agent) => agent.id === DEFAULT_AGENT_ID);
+        if (!ceoExists) {
+            await this.agentService.ensureAgent(paths, {
                 id: DEFAULT_AGENT_ID,
                 displayName: "CEO",
             }, {
@@ -188,7 +195,6 @@ export class OpenGoatService {
                 reportsTo: null,
                 role: "CEO",
             });
-            ceoDescriptor = created.agent;
         }
         try {
             await this.syncOpenClawRoleSkills(paths, DEFAULT_AGENT_ID);
@@ -196,42 +202,50 @@ export class OpenGoatService {
         catch (error) {
             warnings.push(`OpenClaw role skill assignment sync for "ceo" failed: ${toErrorMessage(error)}`);
         }
+        let openClawAgentEntriesById;
         try {
-            const ceoSync = await this.providerService.createProviderAgent(paths, DEFAULT_AGENT_ID, {
-                providerId: OPENCLAW_PROVIDER_ID,
-                displayName: ceoDescriptor.displayName,
-                workspaceDir: ceoDescriptor.workspaceDir,
-                internalConfigDir: ceoDescriptor.internalConfigDir,
-            });
-            ceoSyncCode = ceoSync.code;
-            ceoSynced =
-                ceoSync.code === 0 ||
-                    containsAlreadyExistsMessage(ceoSync.stdout, ceoSync.stderr);
-            if (!ceoSynced) {
-                warnings.push(`OpenClaw sync for "ceo" failed (code ${ceoSync.code}). ${(ceoSync.stderr || ceoSync.stdout).trim()}`);
-            }
+            openClawAgentEntriesById = new Map((await this.listOpenClawAgents(paths)).map((entry) => [entry.id, entry]));
         }
         catch (error) {
-            warnings.push(`OpenClaw sync for "ceo" failed: ${toErrorMessage(error)}`);
+            warnings.push(`OpenClaw startup inventory check failed: ${toErrorMessage(error)}`);
         }
-        if (ceoSynced) {
-            try {
-                await this.ensureOpenClawAgentLocation(paths, {
-                    agentId: DEFAULT_AGENT_ID,
-                    displayName: ceoDescriptor.displayName,
-                    workspaceDir: ceoDescriptor.workspaceDir,
-                    internalConfigDir: ceoDescriptor.internalConfigDir,
+        try {
+            localAgents = await this.agentService.listAgents(paths);
+            for (const agent of localAgents) {
+                const sync = await this.syncOpenClawAgentRegistration(paths, {
+                    descriptor: agent,
+                    existingEntry: openClawAgentEntriesById?.get(agent.id),
                 });
+                warnings.push(...sync.warnings);
+                if (agent.id === DEFAULT_AGENT_ID) {
+                    ceoSynced = sync.synced;
+                    ceoSyncCode = sync.code;
+                }
             }
-            catch (error) {
-                warnings.push(`OpenClaw ceo location sync failed: ${toErrorMessage(error)}`);
-            }
+        }
+        catch (error) {
+            warnings.push(`OpenClaw startup sync failed: ${toErrorMessage(error)}`);
+        }
+        try {
+            warnings.push(...(await this.syncOpenClawAgentExecutionPolicies(paths, localAgents.map((agent) => agent.id))));
+        }
+        catch (error) {
+            warnings.push(`OpenClaw agent policy sync failed: ${toErrorMessage(error)}`);
         }
         try {
-            await this.agentService.ensureCeoWorkspaceBootstrap(paths);
+            warnings.push(...(await this.ensureOpenGoatPluginToolsRegistered(paths)));
         }
         catch (error) {
-            warnings.push(`OpenGoat workspace bootstrap for "ceo" failed: ${toErrorMessage(error)}`);
+            warnings.push(`OpenClaw plugin tool sync failed: ${toErrorMessage(error)}`);
+        }
+        try {
+            const agents = await this.agentService.listAgents(paths);
+            for (const agent of agents) {
+                await this.agentService.ensureAgentWorkspaceCommandShim(paths, agent.id);
+            }
+        }
+        catch (error) {
+            warnings.push(`OpenGoat workspace command shim sync failed: ${toErrorMessage(error)}`);
         }
         return {
             ceoSyncCode,
@@ -241,6 +255,10 @@ export class OpenGoatService {
     }
     async createAgent(rawName, options = {}) {
         const identity = this.agentService.normalizeAgentName(rawName);
+        const managerAgentId = resolveCreateAgentManagerId(identity.id, options.reportsTo);
+        if (managerAgentId) {
+            await this.assertManagerSupportsReportees(managerAgentId);
+        }
         const paths = this.pathsProvider.getPaths();
         const created = await this.agentService.ensureAgent(paths, identity, {
             type: options.type,
@@ -287,12 +305,15 @@ export class OpenGoatService {
             }
             throw new Error(`OpenClaw agent location sync failed for "${created.agent.id}". ${toErrorMessage(error)}`);
         }
+        await this.syncOpenClawAgentExecutionPolicies(paths, [created.agent.id]);
         try {
             const workspaceBootstrap = await this.agentService.ensureAgentWorkspaceBootstrap(paths, {
                 agentId: created.agent.id,
                 displayName: created.agent.displayName,
                 role: options.role?.trim() ??
                     (created.alreadyExisted ? created.agent.role : ""),
+            }, {
+                syncBootstrapMarkdown: false,
             });
             created.createdPaths.push(...workspaceBootstrap.createdPaths);
             created.skippedPaths.push(...workspaceBootstrap.skippedPaths);
@@ -390,12 +411,13 @@ export class OpenGoatService {
             this.agentService.listAgents(paths),
             this.agentManifestService.listManifests(paths),
         ]);
+        const reporteeStats = buildReporteeStats(manifests);
         const descriptorsById = new Map(agents.map((agent) => [agent.id, agent]));
         const agent = descriptorsById.get(agentId);
         if (!agent) {
             throw new Error(`Agent "${agentId}" does not exist.`);
         }
-        const totalReportees = collectAllReportees(manifests, agentId).length;
+        const totalReportees = reporteeStats.totalByManager.get(agentId) ?? 0;
         const directReportees = manifests
             .filter((manifest) => manifest.metadata.reportsTo === agentId)
             .map((manifest) => {
@@ -408,8 +430,7 @@ export class OpenGoatService {
                 id: manifest.agentId,
                 name,
                 role,
-                totalReportees: collectAllReportees(manifests, manifest.agentId)
-                    .length,
+                totalReportees: reporteeStats.totalByManager.get(manifest.agentId) ?? 0,
             };
         })
             .sort((left, right) => left.id.localeCompare(right.id));
@@ -445,7 +466,9 @@ export class OpenGoatService {
     }
     async setAgentProvider(agentId, providerId) {
         const paths = this.pathsProvider.getPaths();
-        return this.providerService.setAgentProvider(paths, agentId, providerId);
+        const binding = await this.providerService.setAgentProvider(paths, agentId, providerId);
+        await this.ensureAgentProviderRoleSkills(paths, binding.agentId);
+        return binding;
     }
     async getOpenClawGatewayConfig() {
         const paths = this.pathsProvider.getPaths();
@@ -503,94 +526,161 @@ export class OpenGoatService {
         const paths = this.pathsProvider.getPaths();
         return this.boardService.addTaskWorklog(paths, actorId, taskId, content);
     }
+    async assertManagerSupportsReportees(managerAgentId) {
+        const paths = this.pathsProvider.getPaths();
+        const agents = await this.agentService.listAgents(paths);
+        if (!agents.some((agent) => agent.id === managerAgentId)) {
+            return;
+        }
+        const managerBinding = await this.providerService.getAgentProvider(paths, managerAgentId);
+        const providers = await this.providerService.listProviders();
+        const provider = providers.find((candidate) => candidate.id === managerBinding.providerId);
+        if (!provider) {
+            throw new Error(`Provider "${managerBinding.providerId}" is not available for manager "${managerAgentId}".`);
+        }
+        if (!provider.capabilities.reportees) {
+            throw new Error(`Cannot assign "${managerAgentId}" as manager because provider "${provider.displayName}" does not support reportees.`);
+        }
+    }
     async runTaskCronCycle(options = {}) {
         const paths = this.pathsProvider.getPaths();
         const ranAt = this.resolveNowIso();
         const manifests = await this.agentManifestService.listManifests(paths);
-        const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
         const inactiveMinutes = resolveInactiveMinutes(options.inactiveMinutes);
         const notificationTarget = resolveInactiveAgentNotificationTarget(options.notificationTarget);
         const notifyInactiveAgents = options.notifyInactiveAgents ?? true;
+        const maxParallelFlows = resolveMaxParallelFlows(options.maxParallelFlows);
         const inactiveCandidates = notifyInactiveAgents
             ? await this.collectInactiveAgents(paths, manifests, inactiveMinutes, notificationTarget)
             : [];
-        const latestCeoProjectPath = notifyInactiveAgents
-            ? await this.resolveLatestProjectPathForAgent(paths, DEFAULT_AGENT_ID)
-            : undefined;
         const tasks = await this.boardService.listTasks(paths, { limit: 10_000 });
-        const dispatches = [];
-        let scannedTasks = tasks.length;
+        const pendingTaskIds = new Set(await this.boardService.listPendingTaskIdsOlderThan(paths, inactiveMinutes));
+        const taskStatusDispatch = await this.dispatchTaskStatusAutomations(paths, tasks, manifests, pendingTaskIds, inactiveMinutes, ranAt, maxParallelFlows);
+        const inactiveDispatches = await this.dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, ranAt, maxParallelFlows);
+        const dispatches = [
+            ...taskStatusDispatch.dispatches,
+            ...inactiveDispatches,
+        ];
+        const failed = dispatches.filter((entry) => !entry.ok).length;
+        return {
+            ranAt,
+            scannedTasks: tasks.length,
+            todoTasks: taskStatusDispatch.todoTasks,
+            blockedTasks: taskStatusDispatch.blockedTasks,
+            inactiveAgents: inactiveCandidates.length,
+            sent: dispatches.length - failed,
+            failed,
+            dispatches,
+        };
+    }
+    async dispatchTaskStatusAutomations(paths, tasks, manifests, pendingTaskIds, pendingMinutes, notificationTimestamp, maxParallelFlows) {
+        const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
+        const requests = [];
         let todoTasks = 0;
+        let pendingTasks = 0;
         let blockedTasks = 0;
         for (const task of tasks) {
-            if (task.status !== "todo" && task.status !== "blocked") {
-                continue;
-            }
             if (task.status === "todo") {
                 todoTasks += 1;
                 const targetAgentId = task.assignedTo;
-                const sessionRef = buildTaskSessionRef(targetAgentId, task.taskId);
-                const message = buildTodoTaskMessage({ task });
-                const result = await this.dispatchAutomationMessage(paths, targetAgentId, sessionRef, message);
-                dispatches.push({
+                const sessionRef = buildNotificationSessionRef(targetAgentId);
+                const message = buildTodoTaskMessage({
+                    task,
+                    notificationTimestamp,
+                });
+                requests.push({
                     kind: "todo",
                     targetAgentId,
                     sessionRef,
                     taskId: task.taskId,
-                    ok: result.ok,
-                    error: result.error,
+                    message,
                 });
                 continue;
             }
-            blockedTasks += 1;
-            const assigneeManifest = manifestsById.get(task.assignedTo);
-            const managerAgentId = normalizeAgentId(assigneeManifest?.metadata.reportsTo ?? "") ||
-                DEFAULT_AGENT_ID;
-            const sessionRef = buildTaskSessionRef(managerAgentId, task.taskId);
-            const message = buildBlockedTaskMessage({ task });
-            const result = await this.dispatchAutomationMessage(paths, managerAgentId, sessionRef, message);
-            dispatches.push({
-                kind: "blocked",
-                targetAgentId: managerAgentId,
-                sessionRef,
-                taskId: task.taskId,
+            if (task.status === "pending") {
+                if (!pendingTaskIds.has(task.taskId)) {
+                    continue;
+                }
+                pendingTasks += 1;
+                const targetAgentId = task.assignedTo;
+                const sessionRef = buildNotificationSessionRef(targetAgentId);
+                const message = buildPendingTaskMessage({
+                    task,
+                    pendingMinutes,
+                    notificationTimestamp,
+                });
+                requests.push({
+                    kind: "pending",
+                    targetAgentId,
+                    sessionRef,
+                    taskId: task.taskId,
+                    message,
+                });
+                continue;
+            }
+            if (task.status === "blocked") {
+                blockedTasks += 1;
+                const assigneeManifest = manifestsById.get(task.assignedTo);
+                const managerAgentId = normalizeAgentId(assigneeManifest?.metadata.reportsTo ?? "") ||
+                    DEFAULT_AGENT_ID;
+                const sessionRef = buildNotificationSessionRef(managerAgentId);
+                const message = buildBlockedTaskMessage({
+                    task,
+                    notificationTimestamp,
+                });
+                requests.push({
+                    kind: "blocked",
+                    targetAgentId: managerAgentId,
+                    sessionRef,
+                    taskId: task.taskId,
+                    message,
+                });
+            }
+        }
+        const dispatches = await runWithConcurrencyByKey(requests, maxParallelFlows, (request) => normalizeAgentId(request.targetAgentId) || DEFAULT_AGENT_ID, async (request) => {
+            const result = await this.dispatchAutomationMessage(paths, request.targetAgentId, request.sessionRef, request.message);
+            return {
+                kind: request.kind,
+                targetAgentId: request.targetAgentId,
+                sessionRef: request.sessionRef,
+                taskId: request.taskId,
+                message: request.message,
                 ok: result.ok,
                 error: result.error,
-            });
-        }
-        for (const candidate of inactiveCandidates) {
-            const sessionRef = buildInactiveSessionRef(candidate.managerAgentId, candidate.subjectAgentId);
+            };
+        });
+        return {
+            dispatches,
+            todoTasks,
+            pendingTasks,
+            blockedTasks,
+        };
+    }
+    async dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, notificationTimestamp, maxParallelFlows = 1) {
+        return runWithConcurrencyByKey(inactiveCandidates, maxParallelFlows, (candidate) => normalizeAgentId(candidate.managerAgentId) || DEFAULT_AGENT_ID, async (candidate) => {
+            const sessionRef = buildNotificationSessionRef(candidate.managerAgentId);
             const message = buildInactiveAgentMessage({
                 managerAgentId: candidate.managerAgentId,
                 subjectAgentId: candidate.subjectAgentId,
                 subjectName: candidate.subjectName,
                 role: candidate.role,
+                directReporteesCount: candidate.directReporteesCount,
+                indirectReporteesCount: candidate.indirectReporteesCount,
                 inactiveMinutes,
+                notificationTimestamp,
                 lastActionTimestamp: candidate.lastActionTimestamp,
             });
-            const result = await this.dispatchAutomationMessage(paths, candidate.managerAgentId, sessionRef, message, {
-                cwd: latestCeoProjectPath,
-            });
-            dispatches.push({
+            const result = await this.dispatchAutomationMessage(paths, candidate.managerAgentId, sessionRef, message);
+            return {
                 kind: "inactive",
                 targetAgentId: candidate.managerAgentId,
                 sessionRef,
                 subjectAgentId: candidate.subjectAgentId,
+                message,
                 ok: result.ok,
                 error: result.error,
-            });
-        }
-        const failed = dispatches.filter((entry) => !entry.ok).length;
-        return {
-            ranAt,
-            scannedTasks,
-            todoTasks,
-            blockedTasks,
-            inactiveAgents: inactiveCandidates.length,
-            sent: dispatches.length - failed,
-            failed,
-            dispatches,
-        };
+            };
+        });
     }
     async listSkills(agentId = DEFAULT_AGENT_ID) {
         const paths = this.pathsProvider.getPaths();
@@ -645,7 +735,6 @@ export class OpenGoatService {
         const paths = this.pathsProvider.getPaths();
         const prepared = await this.sessionService.prepareRunSession(paths, agentId, {
             sessionRef: options.sessionRef,
-            projectPath: options.projectPath,
             forceNew: options.forceNew,
             userMessage: "",
         });
@@ -689,6 +778,7 @@ export class OpenGoatService {
             const result = await this.orchestrationService.runAgent(paths, agentId, {
                 message,
                 sessionRef,
+                disableSession: options.disableSession ?? false,
                 cwd: options.cwd,
                 env: process.env,
             });
@@ -743,7 +833,7 @@ export class OpenGoatService {
                 return;
             }
             syncedAgents.add(targetAgentId);
-            const sync = await this.agentService.ensureAgentWorkspaceRoleSkills(paths, targetAgentId);
+            const sync = await this.ensureAgentProviderRoleSkills(paths, targetAgentId);
             createdPaths.push(...sync.createdPaths);
             skippedPaths.push(...sync.skippedPaths);
             removedPaths.push(...sync.removedPaths);
@@ -781,6 +871,7 @@ export class OpenGoatService {
         for (const legacySkillId of [
             "board-manager",
             "board-individual",
+            "og-boards",
             "og-board-manager",
             "og-board-individual",
             "manager",
@@ -800,6 +891,18 @@ export class OpenGoatService {
             removedPaths,
         };
     }
+    async ensureAgentProviderRoleSkills(paths, rawAgentId) {
+        const agentId = normalizeAgentId(rawAgentId);
+        if (!agentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const runtimeProfile = await this.providerService.getAgentRuntimeProfile(paths, agentId);
+        const managedRoleSkillDirectories = await this.providerService.listProviderRoleSkillDirectories();
+        return this.agentService.ensureAgentWorkspaceRoleSkills(paths, agentId, {
+            requiredSkillDirectories: runtimeProfile.roleSkillDirectories,
+            managedSkillDirectories: managedRoleSkillDirectories,
+        });
+    }
     async resolveOpenClawManagedSkillsDir(paths) {
         if (this.openClawManagedSkillsDirCache !== undefined) {
             return this.openClawManagedSkillsDirCache;
@@ -809,20 +912,28 @@ export class OpenGoatService {
             ...process.env,
             ...(providerConfig?.env ?? {}),
         };
-        const skillsList = await this.runOpenClaw(["skills", "list", "--json"], {
-            env,
-        });
-        if (skillsList.code !== 0) {
-            throw new Error(`OpenClaw skills list failed (exit ${skillsList.code}). ${skillsList.stderr.trim() || skillsList.stdout.trim() || ""}`.trim());
-        }
-        let parsed;
         try {
-            parsed = JSON.parse(skillsList.stdout);
+            const skillsList = await this.runOpenClaw(["skills", "list", "--json"], {
+                env,
+            });
+            if (skillsList.code !== 0) {
+                throw new Error(`OpenClaw skills list failed (exit ${skillsList.code}). ${skillsList.stderr.trim() || skillsList.stdout.trim() || ""}`.trim());
+            }
+            const parsed = parseLooseJson(skillsList.stdout);
+            if (parsed === undefined) {
+                throw new Error("OpenClaw skills list returned non-JSON output; cannot resolve managed skills directory.");
+            }
+            const managedSkillsDir = extractManagedSkillsDir(parsed);
+            this.openClawManagedSkillsDirCache = managedSkillsDir;
+            return managedSkillsDir;
         }
-        catch {
-            throw new Error("OpenClaw skills list returned non-JSON output; cannot resolve managed skills directory.");
+        catch (error) {
+            if (!(error instanceof ProviderCommandNotFoundError)) {
+                throw error;
+            }
         }
-        const managedSkillsDir = extractManagedSkillsDir(parsed);
+        const skillsStatus = await this.providerService.getOpenClawSkillsStatusViaGateway(paths, env);
+        const managedSkillsDir = extractManagedSkillsDir(skillsStatus);
         this.openClawManagedSkillsDirCache = managedSkillsDir;
         return managedSkillsDir;
     }
@@ -831,20 +942,30 @@ export class OpenGoatService {
             return [];
         }
         const env = await this.resolveOpenClawEnv(paths);
-        const listed = await this.runOpenClaw(["agents", "list", "--json"], {
-            env,
-        });
-        if (listed.code !== 0) {
-            throw new Error(`OpenClaw agents list failed (exit ${listed.code}). ${listed.stderr.trim() || listed.stdout.trim() || ""}`.trim());
-        }
-        let parsed;
         try {
-            parsed = JSON.parse(listed.stdout);
+            const listed = await this.runOpenClaw(["agents", "list", "--json"], {
+                env,
+            });
+            if (listed.code !== 0) {
+                throw new Error(`OpenClaw agents list failed (exit ${listed.code}). ${listed.stderr.trim() || listed.stdout.trim() || ""}`.trim());
+            }
+            const parsed = parseLooseJson(listed.stdout);
+            if (parsed === undefined) {
+                throw new Error("OpenClaw agents list returned non-JSON output; cannot inspect agents.");
+            }
+            return extractOpenClawAgents(parsed);
         }
-        catch {
-            throw new Error("OpenClaw agents list returned non-JSON output; cannot inspect agents.");
+        catch (error) {
+            if (!(error instanceof ProviderCommandNotFoundError)) {
+                throw error;
+            }
         }
-        return extractOpenClawAgents(parsed);
+        const entries = await this.providerService.listOpenClawAgentsViaGateway(paths, env);
+        return entries.map((entry) => ({
+            id: entry.id,
+            workspace: entry.workspace,
+            agentDir: entry.agentDir,
+        }));
     }
     async addWorkspaceAgentCandidates(paths, candidates, warnings) {
         try {
@@ -861,25 +982,66 @@ export class OpenGoatService {
             warnings.push(`Workspace fallback discovery failed: ${toErrorMessage(error)}`);
         }
     }
-    async ensureOpenClawAgentLocation(paths, params) {
-        if (!this.commandRunner) {
-            return;
+    async syncOpenClawAgentRegistration(paths, params) {
+        const warnings = [];
+        if (params.existingEntry &&
+            pathMatches(params.existingEntry.workspace, params.descriptor.workspaceDir) &&
+            pathMatches(params.existingEntry.agentDir, params.descriptor.internalConfigDir)) {
+            return {
+                synced: true,
+                code: 0,
+                warnings,
+            };
         }
-        const env = await this.resolveOpenClawEnv(paths);
-        const listed = await this.runOpenClaw(["agents", "list", "--json"], {
-            env,
-        });
-        if (listed.code !== 0) {
-            throw new Error(`OpenClaw agents list failed (exit ${listed.code}). ${listed.stderr.trim() || listed.stdout.trim() || ""}`.trim());
+        let runtimeSync;
+        try {
+            runtimeSync = await this.providerService.createProviderAgent(paths, params.descriptor.id, {
+                providerId: OPENCLAW_PROVIDER_ID,
+                displayName: params.descriptor.displayName,
+                workspaceDir: params.descriptor.workspaceDir,
+                internalConfigDir: params.descriptor.internalConfigDir,
+            });
+        }
+        catch (error) {
+            warnings.push(`OpenClaw sync for "${params.descriptor.id}" failed: ${toErrorMessage(error)}`);
+            return {
+                synced: false,
+                warnings,
+            };
+        }
+        const synced = runtimeSync.code === 0 ||
+            containsAlreadyExistsMessage(runtimeSync.stdout, runtimeSync.stderr);
+        if (!synced) {
+            warnings.push(`OpenClaw sync for "${params.descriptor.id}" failed (code ${runtimeSync.code}). ${(runtimeSync.stderr || runtimeSync.stdout).trim()}`);
+            return {
+                synced,
+                code: runtimeSync.code,
+                warnings,
+            };
         }
-        let parsed;
         try {
-            parsed = JSON.parse(listed.stdout);
+            await this.ensureOpenClawAgentLocation(paths, {
+                agentId: params.descriptor.id,
+                displayName: params.descriptor.displayName,
+                workspaceDir: params.descriptor.workspaceDir,
+                internalConfigDir: params.descriptor.internalConfigDir,
+            }, params.existingEntry);
         }
-        catch {
-            throw new Error("OpenClaw agents list returned non-JSON output; cannot verify agent location.");
+        catch (error) {
+            warnings.push(`OpenClaw location sync for "${params.descriptor.id}" failed: ${toErrorMessage(error)}`);
         }
-        const entry = extractOpenClawAgentEntry(parsed, params.agentId);
+        return {
+            synced,
+            code: runtimeSync.code,
+            warnings,
+        };
+    }
+    async ensureOpenClawAgentLocation(paths, params, existingEntry) {
+        if (!this.commandRunner) {
+            return;
+        }
+        const entry = existingEntry ??
+            (await this.listOpenClawAgents(paths)).find((candidate) => candidate.id === normalizeAgentId(params.agentId));
         if (!entry) {
             return;
         }
@@ -902,6 +1064,219 @@ export class OpenGoatService {
             throw new Error(`OpenClaw agent location repair failed creating "${params.agentId}" (exit ${recreated.code}). ${recreated.stderr.trim() || recreated.stdout.trim() || ""}`.trim());
         }
     }
+    async syncOpenClawAgentExecutionPolicies(paths, rawAgentIds) {
+        if (!this.commandRunner) {
+            return [];
+        }
+        const agentIds = [
+            ...new Set(rawAgentIds
+                .map((agentId) => normalizeAgentId(agentId))
+                .filter((agentId) => Boolean(agentId))),
+        ];
+        if (agentIds.length === 0) {
+            return [];
+        }
+        const warnings = [];
+        const env = await this.resolveOpenClawEnv(paths);
+        let entries;
+        try {
+            const listResult = await this.runOpenClaw(["config", "get", "agents.list"], {
+                env,
+            });
+            if (listResult.code !== 0) {
+                warnings.push(`OpenClaw config read failed (agents.list, code ${listResult.code}). ${listResult.stderr.trim() || listResult.stdout.trim() || ""}`.trim());
+                return warnings;
+            }
+            const parsed = parseLooseJson(listResult.stdout);
+            if (parsed === undefined) {
+                warnings.push("OpenClaw config read returned non-JSON for agents.list; skipping sandbox/tools policy sync.");
+                return warnings;
+            }
+            if (!Array.isArray(parsed)) {
+                warnings.push("OpenClaw config agents.list is not an array; skipping sandbox/tools policy sync.");
+                return warnings;
+            }
+            entries = parsed;
+        }
+        catch (error) {
+            if (!(error instanceof ProviderCommandNotFoundError)) {
+                throw error;
+            }
+            return this.providerService.syncOpenClawAgentExecutionPoliciesViaGateway(paths, agentIds, env);
+        }
+        const indexById = new Map();
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            if (!entry) {
+                continue;
+            }
+            const id = normalizeAgentConfigEntryId(entry);
+            if (!id || indexById.has(id)) {
+                continue;
+            }
+            indexById.set(id, index);
+        }
+        for (const agentId of agentIds) {
+            const index = indexById.get(agentId);
+            if (index === undefined) {
+                warnings.push(`OpenClaw config policy sync skipped for "${agentId}" because no agents.list entry was found.`);
+                continue;
+            }
+            const entry = asRecord(entries[index]);
+            if (readAgentSandboxMode(entry) !== OPENCLAW_AGENT_SANDBOX_MODE) {
+                const sandboxSet = await this.runOpenClaw(["config", "set", `agents.list[${index}].sandbox.mode`, OPENCLAW_AGENT_SANDBOX_MODE], { env });
+                if (sandboxSet.code !== 0) {
+                    warnings.push(`OpenClaw sandbox policy sync failed for "${agentId}" (code ${sandboxSet.code}). ${sandboxSet.stderr.trim() || sandboxSet.stdout.trim() || ""}`.trim());
+                }
+            }
+            if (!hasAgentToolsAllowAll(entry)) {
+                const toolsSet = await this.runOpenClaw(["config", "set", `agents.list[${index}].tools.allow`, OPENCLAW_AGENT_TOOLS_ALLOW_ALL_JSON], { env });
+                if (toolsSet.code !== 0) {
+                    warnings.push(`OpenClaw tools policy sync failed for "${agentId}" (code ${toolsSet.code}). ${toolsSet.stderr.trim() || toolsSet.stdout.trim() || ""}`.trim());
+                }
+            }
+        }
+        return warnings;
+    }
+    async ensureOpenGoatPluginToolsRegistered(paths) {
+        if (!this.commandRunner) {
+            return [];
+        }
+        const warnings = [];
+        const env = await this.resolveOpenClawEnv(paths);
+        const pluginSourcePath = await this.resolveOpenGoatPluginSourcePath();
+        if (!pluginSourcePath) {
+            warnings.push("OpenClaw OpenGoat plugin source path was not found; OpenGoat tools may be unavailable to agents.");
+            return warnings;
+        }
+        warnings.push(...(await this.configureOpenClawPluginSourcePath(env, pluginSourcePath)));
+        return warnings;
+    }
+    async resolveOpenGoatPluginSourcePath() {
+        const explicit = process.env.OPENGOAT_OPENCLAW_PLUGIN_PATH?.trim();
+        const argvEntry = process.argv[1]?.trim();
+        const argvDir = argvEntry ? dirname(resolvePath(argvEntry)) : undefined;
+        const argvPathCandidates = argvDir
+            ? collectPluginPathCandidatesFromArgvDir(argvDir)
+            : [];
+        const candidates = dedupeStrings([
+            explicit,
+            ...argvPathCandidates,
+            resolvePath(process.cwd(), "packages", "openclaw-plugin"),
+            resolvePath(process.cwd(), "dist", "openclaw-plugin"),
+            resolvePath(process.cwd(), "node_modules", "@opengoat", "openclaw-plugin"),
+            argvDir ? resolvePath(argvDir, "..", "dist", "openclaw-plugin") : undefined,
+            argvDir
+                ? resolvePath(argvDir, "..", "node_modules", "@opengoat", "openclaw-plugin")
+                : undefined,
+            argvDir
+                ? resolvePath(argvDir, "..", "..", "@opengoat", "openclaw-plugin")
+                : undefined,
+        ]);
+        for (const candidate of candidates) {
+            const pluginManifestPath = this.pathPort.join(candidate, "openclaw.plugin.json");
+            if (await this.fileSystem.exists(pluginManifestPath)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    async configureOpenClawPluginSourcePath(env, pluginSourcePath) {
+        const warnings = [];
+        const currentPathsResult = await this.runOpenClaw(["config", "get", "plugins.load.paths"], { env });
+        const currentPaths = currentPathsResult.code === 0
+            ? readStringArray(parseLooseJson(currentPathsResult.stdout))
+            : [];
+        const mergedPaths = await this.mergePluginLoadPaths(pluginSourcePath, currentPaths);
+        if (!samePathList(currentPaths, mergedPaths)) {
+            const setPaths = await this.runOpenClaw(["config", "set", "plugins.load.paths", JSON.stringify(mergedPaths)], { env });
+            if (setPaths.code !== 0) {
+                warnings.push(`OpenClaw plugin source path update failed (code ${setPaths.code}). ${setPaths.stderr.trim() || setPaths.stdout.trim() || ""}`.trim());
+            }
+        }
+        const pluginIds = [
+            OPENCLAW_OPENGOAT_PLUGIN_ID,
+            OPENCLAW_OPENGOAT_PLUGIN_ROOT_ID,
+            OPENCLAW_OPENGOAT_PLUGIN_LEGACY_PACK_ID,
+            OPENCLAW_OPENGOAT_PLUGIN_FALLBACK_ID,
+        ];
+        const enableFailures = [];
+        let pluginEnabled = false;
+        let enabledPluginId;
+        for (const pluginId of pluginIds) {
+            const enablePlugin = await this.runOpenClaw(["config", "set", `plugins.entries.${pluginId}.enabled`, "true"], { env });
+            if (enablePlugin.code === 0) {
+                pluginEnabled = true;
+                enabledPluginId = pluginId;
+                break;
+            }
+            const message = enablePlugin.stderr.trim() || enablePlugin.stdout.trim() || "";
+            if (isPluginNotFoundMessage(message)) {
+                continue;
+            }
+            enableFailures.push(`OpenClaw plugin enable failed for "${pluginId}" (code ${enablePlugin.code}). ${message}`.trim());
+        }
+        if (!pluginEnabled) {
+            if (enableFailures.length === 0) {
+                warnings.push(`OpenClaw plugin enable failed: no matching plugin id was found (${pluginIds.join(", ")}).`);
+            }
+            else {
+                warnings.push(...enableFailures);
+            }
+        }
+        if (enabledPluginId) {
+            const idsToDisable = pluginIds.filter((pluginId) => pluginId !== enabledPluginId);
+            for (const pluginId of idsToDisable) {
+                const disablePlugin = await this.runOpenClaw(["config", "set", `plugins.entries.${pluginId}.enabled`, "false"], { env });
+                if (disablePlugin.code === 0) {
+                    continue;
+                }
+                const message = disablePlugin.stderr.trim() || disablePlugin.stdout.trim() || "";
+                if (isPluginNotFoundMessage(message)) {
+                    continue;
+                }
+                warnings.push(`OpenClaw plugin cleanup failed for "${pluginId}" (code ${disablePlugin.code}). ${message}`.trim());
+            }
+        }
+        return warnings;
+    }
+    async mergePluginLoadPaths(pluginSourcePath, currentPaths) {
+        const merged = dedupeStrings([pluginSourcePath, ...currentPaths]);
+        const normalizedPluginSource = resolvePath(pluginSourcePath);
+        const filtered = [];
+        for (const candidate of merged) {
+            const normalizedCandidate = resolvePath(candidate);
+            if (pathMatches(normalizedCandidate, normalizedPluginSource)) {
+                filtered.push(candidate);
+                continue;
+            }
+            const manifestId = await this.readPluginManifestId(candidate);
+            if (manifestId &&
+                isOpenGoatPluginId(manifestId)) {
+                continue;
+            }
+            filtered.push(candidate);
+        }
+        return dedupeStrings(filtered);
+    }
+    async readPluginManifestId(path) {
+        const manifestPath = this.pathPort.join(path, "openclaw.plugin.json");
+        if (!(await this.fileSystem.exists(manifestPath))) {
+            return undefined;
+        }
+        try {
+            const raw = await this.fileSystem.readFile(manifestPath);
+            const parsed = parseLooseJson(raw);
+            const id = asRecord(parsed).id;
+            if (typeof id === "string" && id.trim().length > 0) {
+                return id.trim();
+            }
+        }
+        catch {
+            // Ignore malformed manifests when cleaning up load paths.
+        }
+        return undefined;
+    }
     async resolveOpenClawEnv(paths) {
         const providerConfig = await this.providerService.getProviderConfig(paths, OPENCLAW_PROVIDER_ID);
         return {
@@ -912,6 +1287,7 @@ export class OpenGoatService {
     async collectInactiveAgents(paths, manifests, inactiveMinutes, notificationTarget) {
         const nowMs = this.resolveNowMs();
         const inactiveCutoffMs = nowMs - inactiveMinutes * 60_000;
+        const reporteeStats = buildReporteeStats(manifests);
         const inactive = [];
         for (const manifest of manifests) {
             const managerAgentId = normalizeAgentId(manifest.metadata.reportsTo ?? "");
@@ -926,295 +1302,201 @@ export class OpenGoatService {
             if (lastAction && lastAction.timestamp >= inactiveCutoffMs) {
                 continue;
             }
+            const directReporteesCount = reporteeStats.directByManager.get(manifest.agentId) ?? 0;
+            const totalReporteesCount = reporteeStats.totalByManager.get(manifest.agentId) ?? 0;
+            const indirectReporteesCount = Math.max(0, totalReporteesCount - directReporteesCount);
             inactive.push({
                 managerAgentId,
                 subjectAgentId: manifest.agentId,
                 subjectName: manifest.metadata.name,
                 role: manifest.metadata.description,
+                directReporteesCount,
+                indirectReporteesCount,
                 lastActionTimestamp: lastAction?.timestamp,
             });
         }
         return inactive;
     }
-    async resolveLatestProjectPathForAgent(paths, rawAgentId) {
-        const agentId = normalizeAgentId(rawAgentId);
-        if (!agentId) {
-            return undefined;
-        }
-        const sessions = await this.sessionService.listSessions(paths, agentId);
-        const latestProjectPath = sessions[0]?.projectPath?.trim();
-        return latestProjectPath || undefined;
-    }
-}
-function containsAlreadyExistsMessage(stdout, stderr) {
-    const text = `${stdout}\n${stderr}`.toLowerCase();
-    return /\balready exists?\b/.test(text);
 }
-function containsAgentNotFoundMessage(stdout, stderr) {
-    const text = `${stdout}\n${stderr}`.toLowerCase();
-    return /\b(not found|does not exist|no such agent|unknown agent|could not find|no agent found|not exist)\b/.test(text);
-}
-function toErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
     }
-    return String(error);
+    return value;
 }
-function resolveInactiveMinutes(value) {
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        return 30;
+function normalizeAgentConfigEntryId(value) {
+    const entry = asRecord(value);
+    const id = entry.id;
+    if (typeof id !== "string") {
+        return undefined;
     }
-    return Math.floor(value);
+    return normalizeAgentId(id);
 }
-function resolveInactiveAgentNotificationTarget(value) {
-    return value === "ceo-only" ? "ceo-only" : "all-managers";
+function readAgentSandboxMode(entry) {
+    const sandbox = asRecord(entry.sandbox);
+    const mode = sandbox.mode;
+    if (typeof mode !== "string") {
+        return undefined;
+    }
+    const trimmed = mode.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
 }
-function extractManagedSkillsDir(payload) {
-    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-        return null;
-    }
-    const record = payload;
-    if (typeof record.managedSkillsDir !== "string") {
-        return null;
+function hasAgentToolsAllowAll(entry) {
+    const tools = asRecord(entry.tools);
+    const allow = tools.allow;
+    if (!Array.isArray(allow)) {
+        return false;
     }
-    const managedSkillsDir = record.managedSkillsDir.trim();
-    return managedSkillsDir || null;
+    return allow.some((value) => typeof value === "string" && value.trim() === "*");
 }
-function extractOpenClawAgents(payload) {
-    if (!Array.isArray(payload)) {
+function readStringArray(value) {
+    if (!Array.isArray(value)) {
         return [];
     }
-    const entries = [];
-    for (const entry of payload) {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-            continue;
-        }
-        const record = entry;
-        const id = normalizeAgentId(String(record.id ?? ""));
-        if (!id) {
-            continue;
-        }
-        entries.push({
-            id,
-            workspace: typeof record.workspace === "string" ? record.workspace : "",
-            agentDir: typeof record.agentDir === "string" ? record.agentDir : "",
-        });
-    }
-    return entries;
+    return value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0);
 }
-function extractOpenClawAgentEntry(payload, agentId) {
-    const normalizedAgentId = normalizeAgentId(agentId);
-    if (!normalizedAgentId) {
-        return null;
+async function runWithConcurrency(items, rawConcurrency, worker) {
+    if (items.length === 0) {
+        return [];
     }
-    for (const entry of extractOpenClawAgents(payload)) {
-        if (entry.id !== normalizedAgentId) {
-            continue;
+    const concurrency = Math.max(1, Math.floor(rawConcurrency));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const runWorker = async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
         }
-        return {
-            workspace: entry.workspace,
-            agentDir: entry.agentDir,
-        };
-    }
-    return null;
-}
-function pathMatches(left, right) {
-    const leftNormalized = normalizePathForCompare(left);
-    const rightNormalized = normalizePathForCompare(right);
-    if (!leftNormalized || !rightNormalized) {
-        return false;
-    }
-    return leftNormalized === rightNormalized;
+    };
+    const workerCount = Math.min(concurrency, items.length);
+    const workers = Array.from({ length: workerCount }, () => runWorker());
+    await Promise.all(workers);
+    return results;
 }
-function pathIsWithin(containerPath, candidatePath) {
-    const normalizedContainer = normalizePathForCompare(containerPath);
-    const normalizedCandidate = normalizePathForCompare(candidatePath);
-    if (!normalizedContainer || !normalizedCandidate) {
-        return false;
-    }
-    const relative = path.relative(normalizedContainer, normalizedCandidate);
-    if (!relative) {
-        return true;
+async function runWithConcurrencyByKey(items, rawConcurrency, resolveKey, worker) {
+    if (items.length === 0) {
+        return [];
     }
-    return !relative.startsWith("..") && !path.isAbsolute(relative);
+    const grouped = new Map();
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        const key = resolveKey(item, index).trim().toLowerCase() || "default";
+        const bucket = grouped.get(key) ?? [];
+        bucket.push({ item, index });
+        grouped.set(key, bucket);
+    }
+    const results = new Array(items.length);
+    await runWithConcurrency([...grouped.values()], rawConcurrency, async (entries) => {
+        for (const entry of entries) {
+            results[entry.index] = await worker(entry.item, entry.index);
+        }
+    });
+    return results;
 }
-function normalizePathForCompare(value) {
-    const trimmed = value.trim();
+function parseLooseJson(raw) {
+    const trimmed = raw.trim();
     if (!trimmed) {
-        return "";
-    }
-    const resolved = path.resolve(trimmed);
-    if (process.platform === "win32") {
-        return resolved.toLowerCase();
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        // continue
+    }
+    const starts = dedupeNumbers([
+        trimmed.indexOf("{"),
+        trimmed.indexOf("["),
+        trimmed.lastIndexOf("{"),
+        trimmed.lastIndexOf("["),
+    ]).filter((index) => index >= 0);
+    for (const startIndex of starts) {
+        const candidate = trimmed.slice(startIndex).trim();
+        if (!candidate) {
+            continue;
+        }
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // keep trying candidates
+        }
     }
-    return resolved;
-}
-function buildTaskSessionRef(agentId, taskId) {
-    const normalizedAgentId = normalizeAgentId(agentId) || DEFAULT_AGENT_ID;
-    const normalizedTaskId = normalizeAgentId(taskId) || "task";
-    return `agent:${normalizedAgentId}:agent_${normalizedAgentId}_task_${normalizedTaskId}`;
-}
-function buildInactiveSessionRef(managerAgentId, subjectAgentId) {
-    const manager = normalizeAgentId(managerAgentId) || DEFAULT_AGENT_ID;
-    const subject = normalizeAgentId(subjectAgentId) || "agent";
-    return `agent:${manager}:agent_${manager}_inactive_${subject}`;
-}
-function buildTodoTaskMessage(params) {
-    const blockers = params.task.blockers.length > 0 ? params.task.blockers.join("; ") : "None";
-    const artifacts = params.task.artifacts.length > 0
-        ? params.task.artifacts
-            .map((entry) => `- ${entry.createdAt} @${entry.createdBy}: ${entry.content}`)
-            .join("\n")
-        : "- None";
-    const worklog = params.task.worklog.length > 0
-        ? params.task.worklog
-            .map((entry) => `- ${entry.createdAt} @${entry.createdBy}: ${entry.content}`)
-            .join("\n")
-        : "- None";
-    return [
-        `Task #${params.task.taskId} is assigned to you and currently in TODO. Please work on it now.`,
-        "",
-        `Task ID: ${params.task.taskId}`,
-        `Title: ${params.task.title}`,
-        `Description: ${params.task.description}`,
-        `Project: ${params.task.project}`,
-        `Status: ${params.task.status}`,
-        `Owner: @${params.task.owner}`,
-        `Assigned to: @${params.task.assignedTo}`,
-        `Created at: ${params.task.createdAt}`,
-        `Blockers: ${blockers}`,
-        "Artifacts:",
-        artifacts,
-        "Worklog:",
-        worklog,
-    ].join("\n");
-}
-function buildBlockedTaskMessage(params) {
-    const blockerReason = params.task.blockers.length > 0
-        ? params.task.blockers.join("; ")
-        : params.task.statusReason?.trim() || "no blocker details were provided";
-    const artifacts = params.task.artifacts.length > 0
-        ? params.task.artifacts
-            .map((entry) => `- ${entry.createdAt} @${entry.createdBy}: ${entry.content}`)
-            .join("\n")
-        : "- None";
-    const worklog = params.task.worklog.length > 0
-        ? params.task.worklog
-            .map((entry) => `- ${entry.createdAt} @${entry.createdBy}: ${entry.content}`)
-            .join("\n")
-        : "- None";
-    return [
-        `Task #${params.task.taskId}, assigned to your reportee "@${params.task.assignedTo}" is blocked because of ${blockerReason}. Help unblocking it.`,
-        "",
-        `Task ID: ${params.task.taskId}`,
-        `Title: ${params.task.title}`,
-        `Description: ${params.task.description}`,
-        `Project: ${params.task.project}`,
-        `Status: ${params.task.status}`,
-        `Owner: @${params.task.owner}`,
-        `Assigned to: @${params.task.assignedTo}`,
-        `Created at: ${params.task.createdAt}`,
-        "Artifacts:",
-        artifacts,
-        "Worklog:",
-        worklog,
-    ].join("\n");
+    return undefined;
 }
-function buildInactiveAgentMessage(params) {
-    const lastAction = typeof params.lastActionTimestamp === "number" &&
-        Number.isFinite(params.lastActionTimestamp)
-        ? new Date(params.lastActionTimestamp).toISOString()
-        : null;
-    return [
-        `Your reportee "@${params.subjectAgentId}" (${params.subjectName}) has no activity in the last ${params.inactiveMinutes} minutes.`,
-        ...(params.role ? [`Role: ${params.role}`] : []),
-        ...(lastAction ? [`Last action: ${lastAction}`] : []),
-        "Please check in and unblock progress.",
-    ].join("\n");
+function dedupeNumbers(values) {
+    return [...new Set(values)];
 }
-function assertAgentExists(manifests, agentId) {
-    if (manifests.some((manifest) => manifest.agentId === agentId)) {
-        return;
+function resolveCreateAgentManagerId(agentId, reportsTo) {
+    const normalizedAgentId = normalizeAgentId(agentId);
+    if (isDefaultAgentId(normalizedAgentId)) {
+        return null;
     }
-    throw new Error(`Agent "${agentId}" does not exist.`);
-}
-function collectAllReportees(manifests, managerAgentId) {
-    const byManager = new Map();
-    for (const manifest of manifests) {
-        const reportsTo = manifest.metadata.reportsTo;
-        if (!reportsTo) {
-            continue;
-        }
-        const reportees = byManager.get(reportsTo) ?? [];
-        reportees.push(manifest.agentId);
-        byManager.set(reportsTo, reportees);
+    if (reportsTo === null || reportsTo === undefined) {
+        return DEFAULT_AGENT_ID;
     }
-    const visited = new Set();
-    const queue = [...(byManager.get(managerAgentId) ?? [])];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current || current === managerAgentId || visited.has(current)) {
-            continue;
-        }
-        visited.add(current);
-        queue.push(...(byManager.get(current) ?? []));
+    const normalizedManagerId = normalizeAgentId(reportsTo);
+    if (!normalizedManagerId || normalizedManagerId === normalizedAgentId) {
+        return DEFAULT_AGENT_ID;
     }
-    return [...visited].sort((left, right) => left.localeCompare(right));
+    return normalizedManagerId;
 }
-function prepareOpenClawCommandEnv(env) {
-    const mergedPath = dedupePathEntries([
-        ...resolvePreferredOpenClawCommandPaths(env),
-        ...(env.PATH?.split(path.delimiter) ?? []),
-    ]);
-    return {
-        ...env,
-        PATH: mergedPath.join(path.delimiter),
-    };
+function collectPluginPathCandidatesFromArgvDir(argvDir) {
+    const maxDepth = 8;
+    const candidates = [];
+    let currentDir = argvDir;
+    for (let depth = 0; depth < maxDepth; depth += 1) {
+        candidates.push(resolvePath(currentDir, "packages", "openclaw-plugin"));
+        candidates.push(resolvePath(currentDir, "openclaw-plugin"));
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return dedupeStrings(candidates);
 }
-function resolvePreferredOpenClawCommandPaths(env) {
-    const homeDir = homedir();
-    const preferredPaths = [
-        path.dirname(process.execPath),
-        path.join(homeDir, ".npm-global", "bin"),
-        path.join(homeDir, ".npm", "bin"),
-        path.join(homeDir, ".local", "bin"),
-        path.join(homeDir, ".volta", "bin"),
-        path.join(homeDir, ".fnm", "current", "bin"),
-        path.join(homeDir, ".asdf", "shims"),
-        path.join(homeDir, "bin"),
-    ];
-    const npmPrefixCandidates = dedupePathEntries([
-        env.npm_config_prefix ?? "",
-        env.NPM_CONFIG_PREFIX ?? "",
-        process.env.npm_config_prefix ?? "",
-        process.env.NPM_CONFIG_PREFIX ?? "",
-    ]);
-    for (const prefix of npmPrefixCandidates) {
-        preferredPaths.push(path.join(prefix, "bin"));
-    }
-    if (process.platform === "darwin") {
-        preferredPaths.push("/opt/homebrew/bin", "/opt/homebrew/opt/node@22/bin", "/usr/local/opt/node@22/bin");
-    }
-    return preferredPaths;
-}
-function dedupePathEntries(entries) {
+function dedupeStrings(values) {
     const seen = new Set();
     const deduped = [];
-    for (const rawEntry of entries) {
-        const entry = rawEntry.trim();
-        if (!entry || seen.has(entry)) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (!trimmed || seen.has(trimmed)) {
             continue;
         }
-        seen.add(entry);
-        deduped.push(entry);
+        seen.add(trimmed);
+        deduped.push(trimmed);
     }
     return deduped;
 }
-function isSpawnPermissionOrMissing(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        ((error.code ?? "") === "ENOENT" ||
-            (error.code ?? "") === "EACCES"));
+function samePathList(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        const leftValue = left[index];
+        const rightValue = right[index];
+        if (!leftValue || !rightValue || !pathMatches(leftValue, rightValue)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isOpenGoatPluginId(pluginId) {
+    return [
+        OPENCLAW_OPENGOAT_PLUGIN_ID,
+        OPENCLAW_OPENGOAT_PLUGIN_ROOT_ID,
+        OPENCLAW_OPENGOAT_PLUGIN_LEGACY_PACK_ID,
+        OPENCLAW_OPENGOAT_PLUGIN_FALLBACK_ID,
+    ].includes(pluginId.trim().toLowerCase());
+}
+function isPluginNotFoundMessage(message) {
+    return message.toLowerCase().includes("plugin not found");
 }
 //# sourceMappingURL=opengoat.service.js.map