@opengoat/core 2026.2.14 → 2026.2.15

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

@@ -1,5 +1,3 @@
-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";
@@ -9,10 +7,18 @@ 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, buildInactiveSessionRef, buildReporteeStats, buildTaskSessionRef, buildTodoTaskMessage, collectAllReportees, containsAgentNotFoundMessage, containsAlreadyExistsMessage, extractManagedSkillsDir, extractOpenClawAgents, isSpawnPermissionOrMissing, pathIsWithin, pathMatches, prepareOpenClawCommandEnv, resolveInactiveAgentNotificationTarget, resolveInactiveMinutes, 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 {
-            await this.agentService.ensureCeoWorkspaceBootstrap(paths);
+            warnings.push(...(await this.syncOpenClawAgentExecutionPolicies(paths, localAgents.map((agent) => agent.id))));
         }
         catch (error) {
-            warnings.push(`OpenGoat workspace bootstrap for "ceo" failed: ${toErrorMessage(error)}`);
+            warnings.push(`OpenClaw agent policy sync failed: ${toErrorMessage(error)}`);
+        }
+        try {
+            warnings.push(...(await this.ensureOpenGoatPluginToolsRegistered(paths)));
+        }
+        catch (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,
@@ -287,6 +301,7 @@ 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,
@@ -390,12 +405,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 +424,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));
@@ -507,7 +522,6 @@ export class OpenGoatService {
         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;
@@ -518,8 +532,27 @@ export class OpenGoatService {
             ? await this.resolveLatestProjectPathForAgent(paths, DEFAULT_AGENT_ID)
             : undefined;
         const tasks = await this.boardService.listTasks(paths, { limit: 10_000 });
+        const taskStatusDispatch = await this.dispatchTaskStatusAutomations(paths, tasks, manifests);
+        const inactiveDispatches = await this.dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, latestCeoProjectPath);
+        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) {
+        const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
         const dispatches = [];
-        let scannedTasks = tasks.length;
         let todoTasks = 0;
         let blockedTasks = 0;
         for (const task of tasks) {
@@ -558,6 +591,14 @@ export class OpenGoatService {
                 error: result.error,
             });
         }
+        return {
+            dispatches,
+            todoTasks,
+            blockedTasks,
+        };
+    }
+    async dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, latestCeoProjectPath) {
+        const dispatches = [];
         for (const candidate of inactiveCandidates) {
             const sessionRef = buildInactiveSessionRef(candidate.managerAgentId, candidate.subjectAgentId);
             const message = buildInactiveAgentMessage({
@@ -565,6 +606,8 @@ export class OpenGoatService {
                 subjectAgentId: candidate.subjectAgentId,
                 subjectName: candidate.subjectName,
                 role: candidate.role,
+                directReporteesCount: candidate.directReporteesCount,
+                indirectReporteesCount: candidate.indirectReporteesCount,
                 inactiveMinutes,
                 lastActionTimestamp: candidate.lastActionTimestamp,
             });
@@ -580,17 +623,7 @@ export class OpenGoatService {
                 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,
-        };
+        return dispatches;
     }
     async listSkills(agentId = DEFAULT_AGENT_ID) {
         const paths = this.pathsProvider.getPaths();
@@ -689,6 +722,7 @@ export class OpenGoatService {
             const result = await this.orchestrationService.runAgent(paths, agentId, {
                 message,
                 sessionRef,
+                disableSession: options.disableSession ?? true,
                 cwd: options.cwd,
                 env: process.env,
             });
@@ -815,11 +849,8 @@ export class OpenGoatService {
         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);
-        }
-        catch {
+        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);
@@ -837,11 +868,8 @@ export class OpenGoatService {
         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);
-        }
-        catch {
+        const parsed = parseLooseJson(listed.stdout);
+        if (parsed === undefined) {
             throw new Error("OpenClaw agents list returned non-JSON output; cannot inspect agents.");
         }
         return extractOpenClawAgents(parsed);
@@ -861,25 +889,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)}`);
+        }
+        return {
+            synced,
+            code: runtimeSync.code,
+            warnings,
+        };
+    }
+    async ensureOpenClawAgentLocation(paths, params, existingEntry) {
+        if (!this.commandRunner) {
+            return;
         }
-        const entry = extractOpenClawAgentEntry(parsed, params.agentId);
+        const entry = existingEntry ??
+            (await this.listOpenClawAgents(paths)).find((candidate) => candidate.id === normalizeAgentId(params.agentId));
         if (!entry) {
             return;
         }
@@ -902,6 +971,210 @@ 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);
+        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;
+        }
+        const entries = parsed;
+        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 +1185,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,11 +1200,16 @@ 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,
             });
         }
@@ -946,275 +1225,129 @@ export class OpenGoatService {
         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;
-    }
-    const managedSkillsDir = record.managedSkillsDir.trim();
-    return managedSkillsDir || null;
-}
-function extractOpenClawAgents(payload) {
-    if (!Array.isArray(payload)) {
-        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;
-}
-function extractOpenClawAgentEntry(payload, agentId) {
-    const normalizedAgentId = normalizeAgentId(agentId);
-    if (!normalizedAgentId) {
-        return null;
-    }
-    for (const entry of extractOpenClawAgents(payload)) {
-        if (entry.id !== normalizedAgentId) {
-            continue;
-        }
-        return {
-            workspace: entry.workspace,
-            agentDir: entry.agentDir,
-        };
-    }
-    return null;
-}
-function pathMatches(left, right) {
-    const leftNormalized = normalizePathForCompare(left);
-    const rightNormalized = normalizePathForCompare(right);
-    if (!leftNormalized || !rightNormalized) {
+function hasAgentToolsAllowAll(entry) {
+    const tools = asRecord(entry.tools);
+    const allow = tools.allow;
+    if (!Array.isArray(allow)) {
         return false;
     }
-    return leftNormalized === rightNormalized;
+    return allow.some((value) => typeof value === "string" && value.trim() === "*");
 }
-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;
+function readStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
     }
-    return !relative.startsWith("..") && !path.isAbsolute(relative);
+    return value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0);
 }
-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 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");
-}
-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 assertAgentExists(manifests, agentId) {
-    if (manifests.some((manifest) => manifest.agentId === agentId)) {
-        return;
-    }
-    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) {
+        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;
         }
-        const reportees = byManager.get(reportsTo) ?? [];
-        reportees.push(manifest.agentId);
-        byManager.set(reportsTo, reportees);
-    }
-    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;
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // keep trying candidates
         }
-        visited.add(current);
-        queue.push(...(byManager.get(current) ?? []));
     }
-    return [...visited].sort((left, right) => left.localeCompare(right));
+    return undefined;
 }
-function prepareOpenClawCommandEnv(env) {
-    const mergedPath = dedupePathEntries([
-        ...resolvePreferredOpenClawCommandPaths(env),
-        ...(env.PATH?.split(path.delimiter) ?? []),
-    ]);
-    return {
-        ...env,
-        PATH: mergedPath.join(path.delimiter),
-    };
+function dedupeNumbers(values) {
+    return [...new Set(values)];
 }
-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 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 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