@opengoat/core 2026.2.15 → 2026.2.17

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

@@ -2,7 +2,7 @@ import { AgentManifestService } from "../../agents/application/agent-manifest.se
 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";
@@ -10,7 +10,7 @@ import { ProviderCommandNotFoundError, createDefaultProviderRegistry, } from "..
 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";
+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";
@@ -255,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,
@@ -308,6 +312,8 @@ export class OpenGoatService {
                 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);
@@ -460,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();
@@ -518,6 +526,22 @@ 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();
@@ -525,15 +549,14 @@ export class OpenGoatService {
         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 taskStatusDispatch = await this.dispatchTaskStatusAutomations(paths, tasks, manifests);
-        const inactiveDispatches = await this.dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, latestCeoProjectPath);
+        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,
@@ -550,57 +573,92 @@ export class OpenGoatService {
             dispatches,
         };
     }
-    async dispatchTaskStatusAutomations(paths, tasks, manifests) {
+    async dispatchTaskStatusAutomations(paths, tasks, manifests, pendingTaskIds, pendingMinutes, notificationTimestamp, maxParallelFlows) {
         const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
-        const dispatches = [];
+        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,
-            });
-        }
+            };
+        });
         return {
             dispatches,
             todoTasks,
+            pendingTasks,
             blockedTasks,
         };
     }
-    async dispatchInactiveAgentAutomations(paths, inactiveCandidates, inactiveMinutes, latestCeoProjectPath) {
-        const dispatches = [];
-        for (const candidate of inactiveCandidates) {
-            const sessionRef = buildInactiveSessionRef(candidate.managerAgentId, candidate.subjectAgentId);
+    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,
@@ -609,21 +667,20 @@ export class OpenGoatService {
                 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,
-            });
-        }
-        return dispatches;
+            };
+        });
     }
     async listSkills(agentId = DEFAULT_AGENT_ID) {
         const paths = this.pathsProvider.getPaths();
@@ -678,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: "",
         });
@@ -722,7 +778,7 @@ export class OpenGoatService {
             const result = await this.orchestrationService.runAgent(paths, agentId, {
                 message,
                 sessionRef,
-                disableSession: options.disableSession ?? true,
+                disableSession: options.disableSession ?? false,
                 cwd: options.cwd,
                 env: process.env,
             });
@@ -777,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);
@@ -815,6 +871,7 @@ export class OpenGoatService {
         for (const legacySkillId of [
             "board-manager",
             "board-individual",
+            "og-boards",
             "og-board-manager",
             "og-board-individual",
             "manager",
@@ -834,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;
@@ -843,17 +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());
+        try {
+            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;
         }
-        const parsed = parseLooseJson(skillsList.stdout);
-        if (parsed === undefined) {
-            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;
     }
@@ -862,17 +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());
+        try {
+            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);
         }
-        const parsed = parseLooseJson(listed.stdout);
-        if (parsed === undefined) {
-            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 {
@@ -985,23 +1078,32 @@ export class OpenGoatService {
         }
         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;
+        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;
         }
-        if (!Array.isArray(parsed)) {
-            warnings.push("OpenClaw config agents.list is not an array; skipping sandbox/tools policy sync.");
-            return warnings;
+        catch (error) {
+            if (!(error instanceof ProviderCommandNotFoundError)) {
+                throw error;
+            }
+            return this.providerService.syncOpenClawAgentExecutionPoliciesViaGateway(paths, agentIds, env);
         }
-        const entries = parsed;
         const indexById = new Map();
         for (let index = 0; index < entries.length; index += 1) {
             const entry = entries[index];
@@ -1215,15 +1317,6 @@ export class OpenGoatService {
         }
         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 asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -1264,6 +1357,48 @@ function readStringArray(value) {
         .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
         .filter((entry) => entry.length > 0);
 }
+async function runWithConcurrency(items, rawConcurrency, worker) {
+    if (items.length === 0) {
+        return [];
+    }
+    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);
+        }
+    };
+    const workerCount = Math.min(concurrency, items.length);
+    const workers = Array.from({ length: workerCount }, () => runWorker());
+    await Promise.all(workers);
+    return results;
+}
+async function runWithConcurrencyByKey(items, rawConcurrency, resolveKey, worker) {
+    if (items.length === 0) {
+        return [];
+    }
+    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 parseLooseJson(raw) {
     const trimmed = raw.trim();
     if (!trimmed) {
@@ -1298,6 +1433,20 @@ function parseLooseJson(raw) {
 function dedupeNumbers(values) {
     return [...new Set(values)];
 }
+function resolveCreateAgentManagerId(agentId, reportsTo) {
+    const normalizedAgentId = normalizeAgentId(agentId);
+    if (isDefaultAgentId(normalizedAgentId)) {
+        return null;
+    }
+    if (reportsTo === null || reportsTo === undefined) {
+        return DEFAULT_AGENT_ID;
+    }
+    const normalizedManagerId = normalizeAgentId(reportsTo);
+    if (!normalizedManagerId || normalizedManagerId === normalizedAgentId) {
+        return DEFAULT_AGENT_ID;
+    }
+    return normalizedManagerId;
+}
 function collectPluginPathCandidatesFromArgvDir(argvDir) {
     const maxDepth = 8;
     const candidates = [];