@opengoat/core 2026.2.18-2 → 2026.2.20

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

@@ -10,15 +10,21 @@ 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, buildInactiveAgentsMessage, 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";
 const OPENCLAW_OPENGOAT_PLUGIN_FALLBACK_ID = "workspace";
+const NOTIFICATION_SESSION_COMPACTION_COMMAND = [
+    "/compact",
+    "Keep only the last 3 notification exchanges plus active task ids, statuses, blockers, and explicit next actions.",
+    "Remove redundant older notification chatter.",
+].join(" ");
 export class OpenGoatService {
     fileSystem;
     pathPort;
@@ -205,23 +211,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;
+                    }
                 }
             }
         }
@@ -249,6 +263,12 @@ export class OpenGoatService {
         catch (error) {
             warnings.push(`OpenGoat workspace command shim sync failed: ${toErrorMessage(error)}`);
         }
+        try {
+            await this.agentService.syncWorkspaceReporteeLinks(paths);
+        }
+        catch (error) {
+            warnings.push(`OpenGoat workspace reportees sync failed: ${toErrorMessage(error)}`);
+        }
         return {
             ceoSyncCode,
             ceoSynced,
@@ -308,24 +328,35 @@ export class OpenGoatService {
             throw new Error(`OpenClaw agent location sync failed for "${created.agent.id}". ${toErrorMessage(error)}`);
         }
         await this.syncOpenClawAgentExecutionPolicies(paths, [created.agent.id]);
+        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)}`);
+            }
+        }
         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);
+            const workspaceReporteesSync = await this.agentService.syncWorkspaceReporteeLinks(paths);
+            created.createdPaths.push(...workspaceReporteesSync.createdPaths);
+            created.skippedPaths.push(...workspaceReporteesSync.skippedPaths);
+            created.skippedPaths.push(...workspaceReporteesSync.removedPaths);
         }
         catch (error) {
             if (!created.alreadyExisted) {
                 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 sync reportees workspace links for "${created.agent.id}". ${toErrorMessage(error)}`);
         }
         return {
             ...created,
@@ -354,6 +385,7 @@ export class OpenGoatService {
             throw new Error(`OpenClaw agent deletion failed for "${agentId}" (exit ${runtimeSync.code}). ${runtimeSync.stderr.trim() || runtimeSync.stdout.trim() || ""}`.trim());
         }
         const removed = await this.agentService.removeAgent(paths, agentId);
+        await this.agentService.syncWorkspaceReporteeLinks(paths);
         return {
             ...removed,
             runtimeSync: {
@@ -378,6 +410,7 @@ export class OpenGoatService {
         if (updated.reportsTo) {
             await this.syncOpenClawRoleSkills(paths, updated.reportsTo);
         }
+        await this.agentService.syncWorkspaceReporteeLinks(paths);
         return updated;
     }
     async listAgents() {
@@ -555,18 +588,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,
         ];
@@ -575,6 +613,7 @@ export class OpenGoatService {
             ranAt,
             scannedTasks: tasks.length,
             todoTasks: taskStatusDispatch.todoTasks,
+            doingTasks: taskStatusDispatch.doingTasks,
             blockedTasks: taskStatusDispatch.blockedTasks,
             inactiveAgents: inactiveCandidates.length,
             sent: dispatches.length - failed,
@@ -582,13 +621,71 @@ 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) => isTopDownOpenTaskStatus(task.status))
+            .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) {
+        const orderedTasks = [...tasks].sort(compareTaskCreatedAtAscending);
+        for (const task of orderedTasks) {
             if (task.status === "todo") {
                 todoTasks += 1;
                 const targetAgentId = task.assignedTo;
@@ -606,6 +703,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;
@@ -658,9 +776,17 @@ 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,
         };
@@ -796,14 +922,36 @@ export class OpenGoatService {
         return this.pathsProvider.getPaths();
     }
     async dispatchAutomationMessage(paths, agentId, sessionRef, message, options = {}) {
+        const invoke = async (nextMessage) => this.runAgent(agentId, {
+            message: nextMessage,
+            sessionRef,
+            disableSession: options.disableSession ?? false,
+            cwd: options.cwd,
+            env: process.env,
+        });
         try {
-            const result = await this.orchestrationService.runAgent(paths, agentId, {
-                message,
-                sessionRef,
-                disableSession: options.disableSession ?? false,
-                cwd: options.cwd,
-                env: process.env,
-            });
+            let result = await invoke(message);
+            if (!isNotificationSessionRef(sessionRef) ||
+                options.disableSession === true ||
+                !isContextOverflowError(result.stderr, result.stdout)) {
+                if (result.code !== 0) {
+                    return {
+                        ok: false,
+                        error: (result.stderr ||
+                            result.stdout ||
+                            `Runtime exited with code ${result.code}.`).trim(),
+                    };
+                }
+                return { ok: true };
+            }
+            const binding = await this.providerService.getAgentProvider(paths, agentId);
+            if (binding.providerId === OPENCLAW_PROVIDER_ID &&
+                !message.trim().startsWith("/")) {
+                const compact = await invoke(NOTIFICATION_SESSION_COMPACTION_COMMAND);
+                if (compact.code === 0) {
+                    result = await invoke(message);
+                }
+            }
             if (result.code !== 0) {
                 return {
                     ok: false,
@@ -1162,6 +1310,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;
     }
@@ -1376,6 +1530,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 [];
@@ -1426,16 +1596,38 @@ async function runWithConcurrencyByKey(items, rawConcurrency, resolveKey, worker
     });
     return results;
 }
+function compareTaskCreatedAtAscending(left, right) {
+    const leftTimestamp = Date.parse(left.createdAt);
+    const rightTimestamp = Date.parse(right.createdAt);
+    if (Number.isFinite(leftTimestamp) && Number.isFinite(rightTimestamp)) {
+        const timestampDiff = leftTimestamp - rightTimestamp;
+        if (timestampDiff !== 0) {
+            return timestampDiff;
+        }
+        return left.taskId.localeCompare(right.taskId);
+    }
+    if (Number.isFinite(leftTimestamp)) {
+        return -1;
+    }
+    if (Number.isFinite(rightTimestamp)) {
+        return 1;
+    }
+    return left.taskId.localeCompare(right.taskId);
+}
 function parseLooseJson(raw) {
     const trimmed = raw.trim();
     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("{"),
@@ -1448,11 +1640,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;
@@ -1526,4 +1776,17 @@ function isOpenGoatPluginId(pluginId) {
 function isPluginNotFoundMessage(message) {
     return message.toLowerCase().includes("plugin not found");
 }
+function isNotificationSessionRef(sessionRef) {
+    return sessionRef.trim().toLowerCase().endsWith("_notifications");
+}
+function isContextOverflowError(stderr, stdout) {
+    const combined = `${stderr}\n${stdout}`.toLowerCase();
+    return (combined.includes("context overflow") ||
+        combined.includes("prompt too large") ||
+        combined.includes("context length"));
+}
+function isTopDownOpenTaskStatus(status) {
+    const normalized = status.trim().toLowerCase();
+    return normalized !== "done" && normalized !== "blocked";
+}
 //# sourceMappingURL=opengoat.service.js.map