@opengoat/core 2026.2.17 → 2026.2.19

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

@@ -10,11 +10,12 @@ 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, buildNotificationSessionRef, buildPendingTaskMessage, buildReporteeStats, buildTodoTaskMessage, collectAllReportees, containsAgentNotFoundMessage, containsAlreadyExistsMessage, extractManagedSkillsDir, extractOpenClawAgents, isSpawnPermissionOrMissing, pathIsWithin, pathMatches, prepareOpenClawCommandEnv, resolveInactiveAgentNotificationTarget, resolveInactiveMinutes, resolveMaxParallelFlows, toErrorMessage, } from "./opengoat.service.helpers.js";
+import { assertAgentExists, buildBlockedTaskMessage, buildDoingTaskMessage, buildInactiveAgentsMessage, buildNotificationSessionRef, buildPendingTaskMessage, buildReporteeStats, buildTopDownTaskDelegationMessage, buildTodoTaskMessage, collectAllReportees, containsAgentNotFoundMessage, containsAlreadyExistsMessage, extractManagedSkillsDir, extractOpenClawAgents, isSpawnPermissionOrMissing, pathIsWithin, pathMatches, prepareOpenClawCommandEnv, resolveInProgressTimeoutMinutes, resolveBottomUpTaskDelegationStrategy, resolveTopDownTaskDelegationStrategy, 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_AGENT_SKIP_BOOTSTRAP = true;
 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";
@@ -97,8 +98,10 @@ export class OpenGoatService {
             agentManifestService: this.agentManifestService,
         });
     }
-    initialize() {
-        return this.initializeRuntimeDefaults();
+    initialize(options = {}) {
+        return this.initializeRuntimeDefaults({
+            syncRuntimeDefaults: options.syncRuntimeDefaults ?? true,
+        });
     }
     async hardReset() {
         const paths = this.pathsProvider.getPaths();
@@ -203,23 +206,31 @@ export class OpenGoatService {
             warnings.push(`OpenClaw role skill assignment sync for "ceo" failed: ${toErrorMessage(error)}`);
         }
         let openClawAgentEntriesById;
+        let openClawInventoryAvailable = false;
         try {
             openClawAgentEntriesById = new Map((await this.listOpenClawAgents(paths)).map((entry) => [entry.id, entry]));
+            openClawInventoryAvailable = true;
         }
         catch (error) {
             warnings.push(`OpenClaw startup inventory check failed: ${toErrorMessage(error)}`);
         }
         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;
+            if (!openClawInventoryAvailable) {
+                warnings.push("OpenClaw startup registration sync skipped because agent inventory is unavailable.");
+                ceoSynced = localAgents.some((agent) => agent.id === DEFAULT_AGENT_ID);
+            }
+            else {
+                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;
+                    }
                 }
             }
         }
@@ -306,24 +317,23 @@ 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);
-            created.skippedPaths.push(...workspaceBootstrap.removedPaths);
-        }
-        catch (error) {
-            if (!created.alreadyExisted) {
+        if (!created.alreadyExisted) {
+            try {
+                const workspaceBootstrap = await this.agentService.ensureAgentWorkspaceBootstrap(paths, {
+                    agentId: created.agent.id,
+                    displayName: created.agent.displayName,
+                    role: options.role?.trim() ?? "",
+                }, {
+                    syncBootstrapMarkdown: false,
+                });
+                created.createdPaths.push(...workspaceBootstrap.createdPaths);
+                created.skippedPaths.push(...workspaceBootstrap.skippedPaths);
+                created.skippedPaths.push(...workspaceBootstrap.removedPaths);
+            }
+            catch (error) {
                 await this.agentService.removeAgent(paths, created.agent.id);
+                throw new Error(`Failed to update workspace bootstrap for "${created.agent.id}". ${toErrorMessage(error)}`);
             }
-            throw new Error(`Failed to update workspace bootstrap for "${created.agent.id}". ${toErrorMessage(error)}`);
         }
         return {
             ...created,
@@ -363,6 +373,10 @@ export class OpenGoatService {
         };
     }
     async setAgentManager(rawAgentId, rawReportsTo) {
+        const managerAgentId = resolveCreateAgentManagerId(rawAgentId, rawReportsTo);
+        if (managerAgentId) {
+            await this.assertManagerSupportsReportees(managerAgentId);
+        }
         const paths = this.pathsProvider.getPaths();
         const updated = await this.agentService.setAgentManager(paths, rawAgentId, rawReportsTo);
         await this.syncOpenClawRoleSkills(paths, updated.agentId);
@@ -538,6 +552,9 @@ export class OpenGoatService {
         if (!provider) {
             throw new Error(`Provider "${managerBinding.providerId}" is not available for manager "${managerAgentId}".`);
         }
+        if (provider.id !== OPENCLAW_PROVIDER_ID) {
+            throw new Error(`Cannot assign "${managerAgentId}" as manager because only OpenClaw agents can be managers (found provider "${provider.displayName}").`);
+        }
         if (!provider.capabilities.reportees) {
             throw new Error(`Cannot assign "${managerAgentId}" as manager because provider "${provider.displayName}" does not support reportees.`);
         }
@@ -546,18 +563,23 @@ export class OpenGoatService {
         const paths = this.pathsProvider.getPaths();
         const ranAt = this.resolveNowIso();
         const manifests = await this.agentManifestService.listManifests(paths);
-        const inactiveMinutes = resolveInactiveMinutes(options.inactiveMinutes);
-        const notificationTarget = resolveInactiveAgentNotificationTarget(options.notificationTarget);
-        const notifyInactiveAgents = options.notifyInactiveAgents ?? true;
+        const inProgressMinutes = resolveInProgressTimeoutMinutes(options.inProgressMinutes);
+        const topDownStrategy = resolveTopDownTaskDelegationStrategy(options);
+        const bottomUpStrategy = resolveBottomUpTaskDelegationStrategy(options);
         const maxParallelFlows = resolveMaxParallelFlows(options.maxParallelFlows);
-        const inactiveCandidates = notifyInactiveAgents
-            ? await this.collectInactiveAgents(paths, manifests, inactiveMinutes, notificationTarget)
+        const inactiveCandidates = bottomUpStrategy.enabled
+            ? await this.collectInactiveAgents(paths, manifests, bottomUpStrategy.inactiveMinutes, bottomUpStrategy.notificationTarget)
             : [];
         const tasks = await this.boardService.listTasks(paths, { limit: 10_000 });
-        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 topDownDispatches = topDownStrategy.enabled
+            ? await this.dispatchTopDownTaskDelegationAutomations(paths, tasks, manifests, topDownStrategy.openTasksThreshold, ranAt, maxParallelFlows)
+            : [];
+        const pendingTaskIds = new Set(await this.boardService.listPendingTaskIdsOlderThan(paths, bottomUpStrategy.inactiveMinutes));
+        const doingTaskIds = new Set(await this.boardService.listDoingTaskIdsOlderThan(paths, inProgressMinutes));
+        const taskStatusDispatch = await this.dispatchTaskStatusAutomations(paths, tasks, manifests, doingTaskIds, pendingTaskIds, inProgressMinutes, bottomUpStrategy.inactiveMinutes, ranAt, maxParallelFlows);
+        const inactiveDispatches = await this.dispatchInactiveAgentAutomations(paths, inactiveCandidates, bottomUpStrategy.inactiveMinutes, ranAt, maxParallelFlows);
         const dispatches = [
+            ...topDownDispatches,
             ...taskStatusDispatch.dispatches,
             ...inactiveDispatches,
         ];
@@ -566,6 +588,7 @@ export class OpenGoatService {
             ranAt,
             scannedTasks: tasks.length,
             todoTasks: taskStatusDispatch.todoTasks,
+            doingTasks: taskStatusDispatch.doingTasks,
             blockedTasks: taskStatusDispatch.blockedTasks,
             inactiveAgents: inactiveCandidates.length,
             sent: dispatches.length - failed,
@@ -573,10 +596,67 @@ export class OpenGoatService {
             dispatches,
         };
     }
-    async dispatchTaskStatusAutomations(paths, tasks, manifests, pendingTaskIds, pendingMinutes, notificationTimestamp, maxParallelFlows) {
+    async dispatchTopDownTaskDelegationAutomations(paths, tasks, manifests, openTasksThreshold, notificationTimestamp, maxParallelFlows = 1) {
+        const openTasks = tasks
+            .filter((task) => task.status.trim().toLowerCase() !== "done")
+            .sort((left, right) => {
+            const leftTimestamp = Date.parse(left.updatedAt);
+            const rightTimestamp = Date.parse(right.updatedAt);
+            if (Number.isFinite(leftTimestamp) && Number.isFinite(rightTimestamp)) {
+                return rightTimestamp - leftTimestamp;
+            }
+            if (Number.isFinite(rightTimestamp)) {
+                return 1;
+            }
+            if (Number.isFinite(leftTimestamp)) {
+                return -1;
+            }
+            return right.taskId.localeCompare(left.taskId);
+        });
+        if (openTasks.length > openTasksThreshold) {
+            return [];
+        }
+        const managerAgents = manifests.filter((manifest) => manifest.metadata.type === "manager").length;
+        const ceoDirectReportees = manifests.filter((manifest) => normalizeAgentId(manifest.metadata.reportsTo ?? "") === DEFAULT_AGENT_ID).length;
+        const sessionRef = buildNotificationSessionRef(DEFAULT_AGENT_ID);
+        const message = buildTopDownTaskDelegationMessage({
+            openTasksThreshold,
+            openTasksCount: openTasks.length,
+            totalAgents: manifests.length,
+            managerAgents,
+            ceoDirectReportees,
+            openTasks: openTasks.map((task) => ({
+                taskId: task.taskId,
+                title: task.title,
+                status: task.status,
+                assignedTo: task.assignedTo,
+            })),
+            notificationTimestamp,
+        });
+        const requests = [
+            {
+                targetAgentId: DEFAULT_AGENT_ID,
+                sessionRef,
+                message,
+            },
+        ];
+        return runWithConcurrencyByKey(requests, maxParallelFlows, (request) => request.targetAgentId, async (request) => {
+            const result = await this.dispatchAutomationMessage(paths, request.targetAgentId, request.sessionRef, request.message);
+            return {
+                kind: "topdown",
+                targetAgentId: request.targetAgentId,
+                sessionRef: request.sessionRef,
+                message: request.message,
+                ok: result.ok,
+                error: result.error,
+            };
+        });
+    }
+    async dispatchTaskStatusAutomations(paths, tasks, manifests, doingTaskIds, pendingTaskIds, doingMinutes, pendingMinutes, notificationTimestamp, maxParallelFlows) {
         const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
         const requests = [];
         let todoTasks = 0;
+        let doingTasks = 0;
         let pendingTasks = 0;
         let blockedTasks = 0;
         for (const task of tasks) {
@@ -597,6 +677,27 @@ export class OpenGoatService {
                 });
                 continue;
             }
+            if (task.status === "doing") {
+                if (!doingTaskIds.has(task.taskId)) {
+                    continue;
+                }
+                doingTasks += 1;
+                const targetAgentId = task.assignedTo;
+                const sessionRef = buildNotificationSessionRef(targetAgentId);
+                const message = buildDoingTaskMessage({
+                    task,
+                    doingMinutes,
+                    notificationTimestamp,
+                });
+                requests.push({
+                    kind: "doing",
+                    targetAgentId,
+                    sessionRef,
+                    taskId: task.taskId,
+                    message,
+                });
+                continue;
+            }
             if (task.status === "pending") {
                 if (!pendingTaskIds.has(task.taskId)) {
                     continue;
@@ -649,34 +750,55 @@ export class OpenGoatService {
                 error: result.error,
             };
         });
+        const notifiedDoingTaskIds = dedupeStrings(dispatches
+            .filter((dispatch) => dispatch.kind === "doing" && dispatch.ok)
+            .map((dispatch) => dispatch.taskId)
+            .filter((taskId) => typeof taskId === "string"));
+        await Promise.all(notifiedDoingTaskIds.map(async (taskId) => {
+            await this.boardService.resetTaskStatusTimeout(paths, taskId, "doing");
+        }));
         return {
             dispatches,
             todoTasks,
+            doingTasks,
             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);
+        const groupedCandidatesByManager = new Map();
+        for (const candidate of inactiveCandidates) {
+            const managerAgentId = normalizeAgentId(candidate.managerAgentId) || DEFAULT_AGENT_ID;
+            const bucket = groupedCandidatesByManager.get(managerAgentId) ?? [];
+            bucket.push(candidate);
+            groupedCandidatesByManager.set(managerAgentId, bucket);
+        }
+        const requests = [...groupedCandidatesByManager.entries()]
+            .sort(([leftManagerId], [rightManagerId]) => leftManagerId.localeCompare(rightManagerId))
+            .map(([managerAgentId, candidates]) => {
+            const orderedCandidates = [...candidates].sort((left, right) => left.subjectAgentId.localeCompare(right.subjectAgentId));
+            return {
+                managerAgentId,
+                candidates: orderedCandidates,
+                sessionRef: buildNotificationSessionRef(managerAgentId),
+                message: buildInactiveAgentsMessage({
+                    inactiveMinutes,
+                    notificationTimestamp,
+                    candidates: orderedCandidates,
+                }),
+                subjectAgentId: orderedCandidates.length === 1
+                    ? orderedCandidates[0]?.subjectAgentId
+                    : undefined,
+            };
+        });
+        return runWithConcurrencyByKey(requests, maxParallelFlows, (request) => request.managerAgentId, async (request) => {
+            const result = await this.dispatchAutomationMessage(paths, request.managerAgentId, request.sessionRef, request.message);
             return {
                 kind: "inactive",
-                targetAgentId: candidate.managerAgentId,
-                sessionRef,
-                subjectAgentId: candidate.subjectAgentId,
-                message,
+                targetAgentId: request.managerAgentId,
+                sessionRef: request.sessionRef,
+                subjectAgentId: request.subjectAgentId,
+                message: request.message,
                 ok: result.ok,
                 error: result.error,
             };
@@ -773,9 +895,9 @@ export class OpenGoatService {
     getPaths() {
         return this.pathsProvider.getPaths();
     }
-    async dispatchAutomationMessage(paths, agentId, sessionRef, message, options = {}) {
+    async dispatchAutomationMessage(_paths, agentId, sessionRef, message, options = {}) {
         try {
-            const result = await this.orchestrationService.runAgent(paths, agentId, {
+            const result = await this.runAgent(agentId, {
                 message,
                 sessionRef,
                 disableSession: options.disableSession ?? false,
@@ -802,13 +924,15 @@ export class OpenGoatService {
     resolveNowIso() {
         return this.nowIso();
     }
-    async initializeRuntimeDefaults() {
+    async initializeRuntimeDefaults(options) {
         const initialization = await this.bootstrapService.initialize();
-        try {
-            await this.syncRuntimeDefaults();
-        }
-        catch {
-            // Startup remains functional even if OpenClaw CLI/runtime is unavailable.
+        if (options.syncRuntimeDefaults) {
+            try {
+                await this.syncRuntimeDefaults();
+            }
+            catch {
+                // Startup remains functional even if OpenClaw CLI/runtime is unavailable.
+            }
         }
         return initialization;
     }
@@ -898,9 +1022,12 @@ export class OpenGoatService {
         }
         const runtimeProfile = await this.providerService.getAgentRuntimeProfile(paths, agentId);
         const managedRoleSkillDirectories = await this.providerService.listProviderRoleSkillDirectories();
+        const managedRoleSkillIds = await this.providerService.listProviderRoleSkillIds();
         return this.agentService.ensureAgentWorkspaceRoleSkills(paths, agentId, {
             requiredSkillDirectories: runtimeProfile.roleSkillDirectories,
             managedSkillDirectories: managedRoleSkillDirectories,
+            roleSkillIdsByType: runtimeProfile.roleSkillIds,
+            managedRoleSkillIds,
         });
     }
     async resolveOpenClawManagedSkillsDir(paths) {
@@ -1135,6 +1262,12 @@ export class OpenGoatService {
                     warnings.push(`OpenClaw tools policy sync failed for "${agentId}" (code ${toolsSet.code}). ${toolsSet.stderr.trim() || toolsSet.stdout.trim() || ""}`.trim());
                 }
             }
+            if (readAgentSkipBootstrap(entry) !== OPENCLAW_AGENT_SKIP_BOOTSTRAP) {
+                const bootstrapSet = await this.runOpenClaw(["config", "set", `agents.list[${index}].skipBootstrap`, "true"], { env });
+                if (bootstrapSet.code !== 0) {
+                    warnings.push(`OpenClaw bootstrap policy sync failed for "${agentId}" (code ${bootstrapSet.code}). ${bootstrapSet.stderr.trim() || bootstrapSet.stdout.trim() || ""}`.trim());
+                }
+            }
         }
         return warnings;
     }
@@ -1349,6 +1482,22 @@ function hasAgentToolsAllowAll(entry) {
     }
     return allow.some((value) => typeof value === "string" && value.trim() === "*");
 }
+function readAgentSkipBootstrap(entry) {
+    const value = entry.skipBootstrap;
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return undefined;
+}
 function readStringArray(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -1404,11 +1553,15 @@ function parseLooseJson(raw) {
     if (!trimmed) {
         return undefined;
     }
-    try {
-        return JSON.parse(trimmed);
+    const exact = tryParseJson(trimmed);
+    if (exact !== undefined) {
+        return exact;
     }
-    catch {
-        // continue
+    for (const line of trimmed.split(/\r?\n/)) {
+        const parsedLine = tryParseJson(line.trim());
+        if (parsedLine !== undefined) {
+            return parsedLine;
+        }
     }
     const starts = dedupeNumbers([
         trimmed.indexOf("{"),
@@ -1421,11 +1574,69 @@ function parseLooseJson(raw) {
         if (!candidate) {
             continue;
         }
-        try {
-            return JSON.parse(candidate);
+        const parsedCandidate = tryParseJson(candidate);
+        if (parsedCandidate !== undefined) {
+            return parsedCandidate;
         }
-        catch {
-            // keep trying candidates
+        const balancedCandidate = extractBalancedJsonCandidate(trimmed, startIndex);
+        if (!balancedCandidate) {
+            continue;
+        }
+        const parsedBalancedCandidate = tryParseJson(balancedCandidate);
+        if (parsedBalancedCandidate !== undefined) {
+            return parsedBalancedCandidate;
+        }
+    }
+    return undefined;
+}
+function tryParseJson(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractBalancedJsonCandidate(raw, startIndex) {
+    const opening = raw[startIndex];
+    if (opening !== "{" && opening !== "[") {
+        return undefined;
+    }
+    const closing = opening === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    for (let index = startIndex; index < raw.length; index += 1) {
+        const char = raw[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+            }
+            else if (char === "\\") {
+                escaping = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === opening) {
+            depth += 1;
+            continue;
+        }
+        if (char !== closing) {
+            continue;
+        }
+        depth -= 1;
+        if (depth === 0) {
+            return raw.slice(startIndex, index + 1).trim();
         }
     }
     return undefined;