@opengoat/core 2026.2.9 → 2026.2.13

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

@@ -1,207 +1,424 @@
-import { DEFAULT_AGENT_ID, normalizeAgentId } from "../../domain/agent-id.js";
-import { createNoopLogger } from "../../logging/index.js";
-import { createDefaultProviderRegistry } from "../../providers/index.js";
+import path from "node:path";
+import { homedir } from "node:os";
 import { AgentManifestService } from "../../agents/application/agent-manifest.service.js";
 import { AgentService } from "../../agents/application/agent.service.js";
-import { WorkspaceContextService } from "../../agents/application/workspace-context.service.js";
+import { BoardService, } from "../../boards/index.js";
 import { BootstrapService } from "../../bootstrap/application/bootstrap.service.js";
-import { OrchestrationService } from "../../orchestration/index.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId } from "../../domain/agent-id.js";
+import { createNoopLogger } from "../../logging/index.js";
+import { OrchestrationService, } from "../../orchestration/index.js";
 import { ProviderService } from "../../providers/application/provider.service.js";
-import { SkillService } from "../../skills/index.js";
-import { PluginService } from "../../plugins/index.js";
-import { SessionService } from "../../sessions/index.js";
+import { ProviderCommandNotFoundError, createDefaultProviderRegistry, } from "../../providers/index.js";
+import { SessionService, } from "../../sessions/index.js";
+import { SkillService, } from "../../skills/index.js";
+const OPENCLAW_PROVIDER_ID = "openclaw";
+const OPENCLAW_DEFAULT_AGENT_ID = "main";
 export class OpenGoatService {
+    fileSystem;
+    pathPort;
     pathsProvider;
     agentService;
     agentManifestService;
     bootstrapService;
     providerService;
-    pluginService;
     skillService;
     sessionService;
     orchestrationService;
+    boardService;
+    commandRunner;
+    nowIso;
+    openClawManagedSkillsDirCache;
     constructor(deps) {
         const nowIso = deps.nowIso ?? (() => new Date().toISOString());
-        const rootLogger = (deps.logger ?? createNoopLogger()).child({ scope: "opengoat-service" });
+        const rootLogger = (deps.logger ?? createNoopLogger()).child({
+            scope: "opengoat-service",
+        });
         const providerRegistryFactory = deps.providerRegistry
             ? () => deps.providerRegistry
             : () => createDefaultProviderRegistry();
+        this.fileSystem = deps.fileSystem;
+        this.pathPort = deps.pathPort;
         this.pathsProvider = deps.pathsProvider;
+        this.nowIso = nowIso;
         this.agentService = new AgentService({
             fileSystem: deps.fileSystem,
             pathPort: deps.pathPort,
-            nowIso
+            nowIso,
         });
         this.agentManifestService = new AgentManifestService({
             fileSystem: deps.fileSystem,
-            pathPort: deps.pathPort
+            pathPort: deps.pathPort,
         });
         this.bootstrapService = new BootstrapService({
             fileSystem: deps.fileSystem,
             pathsProvider: deps.pathsProvider,
             agentService: this.agentService,
-            nowIso
-        });
-        const workspaceContextService = new WorkspaceContextService({
-            fileSystem: deps.fileSystem,
-            pathPort: deps.pathPort
+            nowIso,
         });
-        this.pluginService =
-            deps.pluginService ??
-                new PluginService({
-                    fileSystem: deps.fileSystem,
-                    pathPort: deps.pathPort,
-                    commandRunner: deps.commandRunner
-                });
         this.skillService = new SkillService({
             fileSystem: deps.fileSystem,
             pathPort: deps.pathPort,
-            pluginSkillDirsProvider: (paths) => this.pluginService.resolvePluginSkillDirectories(paths)
         });
         this.providerService = new ProviderService({
             fileSystem: deps.fileSystem,
             pathPort: deps.pathPort,
             providerRegistry: providerRegistryFactory,
-            workspaceContextService,
-            skillService: this.skillService,
             nowIso,
-            logger: rootLogger.child({ scope: "provider" })
+            logger: rootLogger.child({ scope: "provider" }),
         });
         this.sessionService = new SessionService({
             fileSystem: deps.fileSystem,
             pathPort: deps.pathPort,
             commandRunner: deps.commandRunner,
             nowIso,
-            nowMs: () => Date.now()
+            nowMs: () => Date.now(),
         });
+        this.commandRunner = deps.commandRunner;
         this.orchestrationService = new OrchestrationService({
             providerService: this.providerService,
-            skillService: this.skillService,
             agentManifestService: this.agentManifestService,
             sessionService: this.sessionService,
-            commandRunner: deps.commandRunner,
             fileSystem: deps.fileSystem,
             pathPort: deps.pathPort,
             nowIso,
-            logger: rootLogger.child({ scope: "orchestration" })
+            logger: rootLogger.child({ scope: "orchestration" }),
+        });
+        this.boardService = new BoardService({
+            fileSystem: deps.fileSystem,
+            pathPort: deps.pathPort,
+            nowIso,
+            agentManifestService: this.agentManifestService,
         });
     }
     initialize() {
-        return this.bootstrapService.initialize();
+        return this.initializeRuntimeDefaults();
     }
-    async createAgent(rawName, options = {}) {
-        const requestedProviderId = options.providerId?.trim();
-        if (requestedProviderId && options.createExternalAgent === true) {
-            const supportsRequestedProvider = await this.providerSupportsExternalAgentCreation(requestedProviderId);
-            if (!supportsRequestedProvider) {
-                throw new Error(`Provider "${requestedProviderId}" does not support external agent creation.`);
+    async hardReset() {
+        const paths = this.pathsProvider.getPaths();
+        const warnings = [];
+        const deletedOpenClawAgents = [];
+        const failedOpenClawAgents = [];
+        const removedOpenClawManagedSkillDirs = [];
+        const candidateOpenClawAgentIds = new Set();
+        const localAgents = await this.agentService.listAgents(paths);
+        for (const agent of localAgents) {
+            if (agent.id === OPENCLAW_DEFAULT_AGENT_ID) {
+                continue;
+            }
+            candidateOpenClawAgentIds.add(agent.id);
+        }
+        try {
+            const openClawAgents = await this.listOpenClawAgents(paths);
+            for (const entry of openClawAgents) {
+                if (entry.id !== OPENCLAW_DEFAULT_AGENT_ID &&
+                    (pathIsWithin(paths.homeDir, entry.workspace) ||
+                        pathIsWithin(paths.homeDir, entry.agentDir))) {
+                    candidateOpenClawAgentIds.add(entry.id);
+                }
+            }
+        }
+        catch (error) {
+            warnings.push(`OpenClaw agent discovery failed: ${toErrorMessage(error)}`);
+        }
+        for (const agentId of [...candidateOpenClawAgentIds].sort((left, right) => left.localeCompare(right))) {
+            if (agentId === OPENCLAW_DEFAULT_AGENT_ID) {
+                continue;
+            }
+            try {
+                const deleted = await this.providerService.deleteProviderAgent(paths, agentId, { providerId: OPENCLAW_PROVIDER_ID });
+                if (deleted.code === 0 ||
+                    containsAgentNotFoundMessage(deleted.stdout, deleted.stderr)) {
+                    deletedOpenClawAgents.push(agentId);
+                    continue;
+                }
+                const failureReason = deleted.stderr.trim() || deleted.stdout.trim();
+                if (!failureReason) {
+                    warnings.push(`OpenClaw delete for "${agentId}" failed with code ${deleted.code}.`);
+                    continue;
+                }
+                failedOpenClawAgents.push({
+                    agentId,
+                    reason: failureReason,
+                });
+            }
+            catch (error) {
+                if (error instanceof ProviderCommandNotFoundError) {
+                    deletedOpenClawAgents.push(agentId);
+                    continue;
+                }
+                failedOpenClawAgents.push({
+                    agentId,
+                    reason: toErrorMessage(error),
+                });
+            }
+        }
+        try {
+            const managedSkillsCleanup = await this.removeOpenClawManagedRoleSkills(paths);
+            removedOpenClawManagedSkillDirs.push(...managedSkillsCleanup.removedPaths);
+        }
+        catch (error) {
+            warnings.push(`OpenClaw managed skills cleanup failed: ${toErrorMessage(error)}`);
+        }
+        await this.fileSystem.removeDir(paths.homeDir);
+        this.openClawManagedSkillsDirCache = undefined;
+        const homeRemoved = !(await this.fileSystem.exists(paths.homeDir));
+        return {
+            homeDir: paths.homeDir,
+            homeRemoved,
+            deletedOpenClawAgents,
+            failedOpenClawAgents,
+            removedOpenClawManagedSkillDirs,
+            warnings,
+        };
+    }
+    async syncRuntimeDefaults() {
+        const paths = this.pathsProvider.getPaths();
+        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, {
+                id: DEFAULT_AGENT_ID,
+                displayName: "CEO",
+            }, {
+                type: "manager",
+                reportsTo: null,
+                role: "CEO",
+            });
+            ceoDescriptor = created.agent;
+        }
+        try {
+            await this.syncOpenClawRoleSkills(paths, DEFAULT_AGENT_ID);
+        }
+        catch (error) {
+            warnings.push(`OpenClaw role skill assignment sync for "ceo" failed: ${toErrorMessage(error)}`);
+        }
+        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()}`);
             }
         }
+        catch (error) {
+            warnings.push(`OpenClaw sync for "ceo" failed: ${toErrorMessage(error)}`);
+        }
+        if (ceoSynced) {
+            try {
+                await this.ensureOpenClawAgentLocation(paths, {
+                    agentId: DEFAULT_AGENT_ID,
+                    displayName: ceoDescriptor.displayName,
+                    workspaceDir: ceoDescriptor.workspaceDir,
+                    internalConfigDir: ceoDescriptor.internalConfigDir,
+                });
+            }
+            catch (error) {
+                warnings.push(`OpenClaw ceo location sync failed: ${toErrorMessage(error)}`);
+            }
+        }
+        try {
+            await this.agentService.ensureCeoWorkspaceBootstrap(paths);
+        }
+        catch (error) {
+            warnings.push(`OpenGoat workspace bootstrap for "ceo" failed: ${toErrorMessage(error)}`);
+        }
+        return {
+            ceoSyncCode,
+            ceoSynced,
+            warnings,
+        };
+    }
+    async createAgent(rawName, options = {}) {
         const identity = this.agentService.normalizeAgentName(rawName);
         const paths = this.pathsProvider.getPaths();
-        const created = await this.agentService.ensureAgent(paths, identity);
-        let binding;
-        if (requestedProviderId) {
-            binding = await this.providerService.setAgentProvider(paths, created.agent.id, requestedProviderId);
-            await this.agentManifestService.syncManifestProvider(paths, created.agent.id, binding.providerId);
-        }
-        const shouldCreateExternalAgentByDefault = Boolean(requestedProviderId)
-            ? options.createExternalAgent !== false
-            : false;
-        const shouldCreateExternalAgentExplicitlyWithoutProvider = !requestedProviderId && options.createExternalAgent === true;
-        if (!shouldCreateExternalAgentByDefault && !shouldCreateExternalAgentExplicitlyWithoutProvider) {
-            return created;
-        }
-        const resolvedBinding = binding ?? (await this.providerService.getAgentProvider(paths, created.agent.id));
-        const supportsExternalAgentCreation = await this.providerSupportsExternalAgentCreation(resolvedBinding.providerId);
-        if (options.createExternalAgent === true && !supportsExternalAgentCreation) {
-            throw new Error(`Provider "${resolvedBinding.providerId}" does not support external agent creation.`);
-        }
-        if (!supportsExternalAgentCreation) {
-            return created;
-        }
-        const externalAgentCreation = await this.providerService.createProviderAgent(paths, created.agent.id, {
-            providerId: resolvedBinding.providerId,
+        const created = await this.agentService.ensureAgent(paths, identity, {
+            type: options.type,
+            reportsTo: options.reportsTo,
+            skills: options.skills,
+            role: options.role,
+        });
+        try {
+            const workspaceSkillSync = await this.syncOpenClawRoleSkills(paths, created.agent.id);
+            created.createdPaths.push(...workspaceSkillSync.createdPaths);
+            created.skippedPaths.push(...workspaceSkillSync.skippedPaths);
+            created.skippedPaths.push(...workspaceSkillSync.removedPaths);
+        }
+        catch (error) {
+            if (!created.alreadyExisted) {
+                await this.agentService.removeAgent(paths, created.agent.id);
+            }
+            throw new Error(`Failed to sync OpenClaw role skills for "${created.agent.id}". ${toErrorMessage(error)}`);
+        }
+        const runtimeSync = await this.providerService.createProviderAgent(paths, created.agent.id, {
+            providerId: OPENCLAW_PROVIDER_ID,
             displayName: created.agent.displayName,
             workspaceDir: created.agent.workspaceDir,
-            internalConfigDir: created.agent.internalConfigDir
+            internalConfigDir: created.agent.internalConfigDir,
         });
+        if (runtimeSync.code !== 0 &&
+            !containsAlreadyExistsMessage(runtimeSync.stdout, runtimeSync.stderr)) {
+            if (!created.alreadyExisted) {
+                await this.agentService.removeAgent(paths, created.agent.id);
+            }
+            throw new Error(`OpenClaw agent creation failed for "${created.agent.id}" (exit ${runtimeSync.code}). ${runtimeSync.stderr.trim() || runtimeSync.stdout.trim() || ""}`.trim());
+        }
+        try {
+            await this.ensureOpenClawAgentLocation(paths, {
+                agentId: created.agent.id,
+                displayName: created.agent.displayName,
+                workspaceDir: created.agent.workspaceDir,
+                internalConfigDir: created.agent.internalConfigDir,
+            });
+        }
+        catch (error) {
+            if (!created.alreadyExisted) {
+                await this.agentService.removeAgent(paths, created.agent.id);
+            }
+            throw new Error(`OpenClaw agent location sync failed 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 : ""),
+            });
+            created.createdPaths.push(...workspaceBootstrap.createdPaths);
+            created.skippedPaths.push(...workspaceBootstrap.skippedPaths);
+            created.skippedPaths.push(...workspaceBootstrap.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)}`);
+        }
         return {
             ...created,
-            externalAgentCreation: {
-                providerId: externalAgentCreation.providerId,
-                code: externalAgentCreation.code,
-                stdout: externalAgentCreation.stdout,
-                stderr: externalAgentCreation.stderr
-            }
+            runtimeSync: {
+                runtimeId: runtimeSync.providerId,
+                code: runtimeSync.code,
+                stdout: runtimeSync.stdout,
+                stderr: runtimeSync.stderr,
+            },
         };
     }
-    async createExternalAgent(rawAgentId, options = {}) {
+    async deleteAgent(rawAgentId, options = {}) {
         const paths = this.pathsProvider.getPaths();
         const agentId = normalizeAgentId(rawAgentId);
         if (!agentId) {
             throw new Error("Agent id cannot be empty.");
         }
-        const agent = (await this.agentService.listAgents(paths)).find((entry) => entry.id === agentId);
-        if (!agent) {
-            throw new Error(`Agent "${agentId}" was not found.`);
-        }
-        const resolvedProviderId = options.providerId?.trim().toLowerCase() ??
-            (await this.providerService.getAgentProvider(paths, agentId)).providerId;
-        const supportsExternalAgentCreation = await this.providerSupportsExternalAgentCreation(resolvedProviderId);
-        if (!supportsExternalAgentCreation) {
-            throw new Error(`Provider "${resolvedProviderId}" does not support external agent creation.`);
-        }
-        const externalAgentCreation = await this.providerService.createProviderAgent(paths, agentId, {
-            providerId: resolvedProviderId,
-            displayName: agent.displayName,
-            workspaceDir: agent.workspaceDir,
-            internalConfigDir: agent.internalConfigDir
+        const existing = (await this.agentService.listAgents(paths)).find((entry) => entry.id === agentId);
+        if (!existing) {
+            return this.agentService.removeAgent(paths, agentId);
+        }
+        const runtimeSync = await this.providerService.deleteProviderAgent(paths, agentId, {
+            providerId: OPENCLAW_PROVIDER_ID,
         });
+        if (runtimeSync.code !== 0 && !options.force) {
+            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);
         return {
-            providerId: externalAgentCreation.providerId,
-            code: externalAgentCreation.code,
-            stdout: externalAgentCreation.stdout,
-            stderr: externalAgentCreation.stderr
+            ...removed,
+            runtimeSync: {
+                runtimeId: runtimeSync.providerId,
+                code: runtimeSync.code,
+                stdout: runtimeSync.stdout,
+                stderr: runtimeSync.stderr,
+            },
         };
     }
-    async providerSupportsExternalAgentCreation(providerId) {
-        const providers = await this.providerService.listProviders();
-        const provider = providers.find((entry) => entry.id === providerId);
-        return Boolean(provider?.capabilities.agentCreate);
+    async setAgentManager(rawAgentId, rawReportsTo) {
+        const paths = this.pathsProvider.getPaths();
+        const updated = await this.agentService.setAgentManager(paths, rawAgentId, rawReportsTo);
+        await this.syncOpenClawRoleSkills(paths, updated.agentId);
+        if (updated.previousReportsTo) {
+            await this.syncOpenClawRoleSkills(paths, updated.previousReportsTo);
+        }
+        if (updated.reportsTo) {
+            await this.syncOpenClawRoleSkills(paths, updated.reportsTo);
+        }
+        return updated;
     }
-    async deleteAgent(rawAgentId, options = {}) {
+    async listAgents() {
         const paths = this.pathsProvider.getPaths();
+        return this.agentService.listAgents(paths);
+    }
+    async listDirectReportees(rawAgentId) {
         const agentId = normalizeAgentId(rawAgentId);
         if (!agentId) {
             throw new Error("Agent id cannot be empty.");
         }
-        let externalProviderId = options.providerId?.trim().toLowerCase();
-        if (options.deleteExternalAgent && !externalProviderId) {
-            const binding = await this.providerService.getAgentProvider(paths, agentId);
-            externalProviderId = binding.providerId;
+        const paths = this.pathsProvider.getPaths();
+        const manifests = await this.agentManifestService.listManifests(paths);
+        assertAgentExists(manifests, agentId);
+        return manifests
+            .filter((manifest) => manifest.metadata.reportsTo === agentId)
+            .map((manifest) => manifest.agentId)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    async listAllReportees(rawAgentId) {
+        const agentId = normalizeAgentId(rawAgentId);
+        if (!agentId) {
+            throw new Error("Agent id cannot be empty.");
         }
-        const removed = await this.agentService.removeAgent(paths, agentId);
-        if (!options.deleteExternalAgent) {
-            return removed;
+        const paths = this.pathsProvider.getPaths();
+        const manifests = await this.agentManifestService.listManifests(paths);
+        assertAgentExists(manifests, agentId);
+        return collectAllReportees(manifests, agentId);
+    }
+    async getAgentInfo(rawAgentId) {
+        const agentId = normalizeAgentId(rawAgentId);
+        if (!agentId) {
+            throw new Error("Agent id cannot be empty.");
         }
-        const externalAgentDeletion = await this.providerService.deleteProviderAgent(paths, agentId, {
-            providerId: externalProviderId
-        });
+        const paths = this.pathsProvider.getPaths();
+        const [agents, manifests] = await Promise.all([
+            this.agentService.listAgents(paths),
+            this.agentManifestService.listManifests(paths),
+        ]);
+        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 directReportees = manifests
+            .filter((manifest) => manifest.metadata.reportsTo === agentId)
+            .map((manifest) => {
+            const descriptor = descriptorsById.get(manifest.agentId);
+            const name = descriptor?.displayName?.trim() ||
+                manifest.metadata.name ||
+                manifest.agentId;
+            const role = descriptor?.role?.trim() || manifest.metadata.description || "Agent";
+            return {
+                id: manifest.agentId,
+                name,
+                role,
+                totalReportees: collectAllReportees(manifests, manifest.agentId)
+                    .length,
+            };
+        })
+            .sort((left, right) => left.id.localeCompare(right.id));
         return {
-            ...removed,
-            externalAgentDeletion: {
-                providerId: externalAgentDeletion.providerId,
-                code: externalAgentDeletion.code,
-                stdout: externalAgentDeletion.stdout,
-                stderr: externalAgentDeletion.stderr
-            }
+            id: agent.id,
+            name: agent.displayName,
+            role: agent.role,
+            totalReportees,
+            directReportees,
         };
     }
-    async listAgents() {
-        const paths = this.pathsProvider.getPaths();
-        return this.agentService.listAgents(paths);
-    }
     listProviders() {
         return this.providerService.listProviders();
     }
@@ -226,9 +443,15 @@ export class OpenGoatService {
     }
     async setAgentProvider(agentId, providerId) {
         const paths = this.pathsProvider.getPaths();
-        const binding = await this.providerService.setAgentProvider(paths, agentId, providerId);
-        await this.agentManifestService.syncManifestProvider(paths, binding.agentId, binding.providerId);
-        return binding;
+        return this.providerService.setAgentProvider(paths, agentId, providerId);
+    }
+    async getOpenClawGatewayConfig() {
+        const paths = this.pathsProvider.getPaths();
+        return this.providerService.getOpenClawGatewayConfig(paths, process.env);
+    }
+    async setOpenClawGatewayConfig(config) {
+        const paths = this.pathsProvider.getPaths();
+        return this.providerService.setOpenClawGatewayConfig(paths, config);
     }
     async routeMessage(agentId, message) {
         const paths = this.pathsProvider.getPaths();
@@ -238,46 +461,192 @@ export class OpenGoatService {
         const paths = this.pathsProvider.getPaths();
         return this.orchestrationService.runAgent(paths, agentId, options);
     }
-    async listSkills(agentId = DEFAULT_AGENT_ID) {
+    async createTask(actorId, options) {
         const paths = this.pathsProvider.getPaths();
-        return this.skillService.listSkills(paths, agentId);
+        return this.boardService.createTask(paths, actorId, options);
     }
-    async listGlobalSkills() {
+    async listTasks(options = {}) {
         const paths = this.pathsProvider.getPaths();
-        return this.skillService.listGlobalSkills(paths);
+        return this.boardService.listTasks(paths, options);
     }
-    async installSkill(request) {
+    async listLatestTasks(options = {}) {
+        const paths = this.pathsProvider.getPaths();
+        return this.boardService.listLatestTasks(paths, options);
+    }
+    async listLatestTasksPage(options = {}) {
         const paths = this.pathsProvider.getPaths();
-        return this.skillService.installSkill(paths, request);
+        return this.boardService.listLatestTasksPage(paths, options);
     }
-    async listPlugins(options = {}) {
+    async getTask(taskId) {
         const paths = this.pathsProvider.getPaths();
-        return this.pluginService.listPlugins(paths, options);
+        return this.boardService.getTask(paths, taskId);
     }
-    async getPluginInfo(pluginId) {
+    async deleteTasks(actorId, taskIds) {
         const paths = this.pathsProvider.getPaths();
-        return this.pluginService.getPluginInfo(paths, pluginId);
+        return this.boardService.deleteTasks(paths, actorId, taskIds);
     }
-    async installPlugin(request) {
+    async updateTaskStatus(actorId, taskId, status, reason) {
         const paths = this.pathsProvider.getPaths();
-        return this.pluginService.installPlugin(paths, request);
+        return this.boardService.updateTaskStatus(paths, actorId, taskId, status, reason);
     }
-    async enablePlugin(pluginId) {
+    async addTaskBlocker(actorId, taskId, blocker) {
         const paths = this.pathsProvider.getPaths();
-        await this.pluginService.enablePlugin(paths, pluginId);
+        return this.boardService.addTaskBlocker(paths, actorId, taskId, blocker);
     }
-    async disablePlugin(pluginId) {
+    async addTaskArtifact(actorId, taskId, content) {
         const paths = this.pathsProvider.getPaths();
-        await this.pluginService.disablePlugin(paths, pluginId);
+        return this.boardService.addTaskArtifact(paths, actorId, taskId, content);
     }
-    async pluginDoctor() {
+    async addTaskWorklog(actorId, taskId, content) {
         const paths = this.pathsProvider.getPaths();
-        return this.pluginService.doctor(paths);
+        return this.boardService.addTaskWorklog(paths, actorId, taskId, content);
+    }
+    async runTaskCronCycle(options = {}) {
+        const paths = this.pathsProvider.getPaths();
+        const ranAt = this.resolveNowIso();
+        const manifests = await this.agentManifestService.listManifests(paths);
+        const manifestsById = new Map(manifests.map((manifest) => [manifest.agentId, manifest]));
+        const inactiveMinutes = resolveInactiveMinutes(options.inactiveMinutes);
+        const inactiveCandidates = await this.collectInactiveAgents(paths, manifests, inactiveMinutes);
+        const tasks = await this.boardService.listTasks(paths, { limit: 10_000 });
+        const dispatches = [];
+        let scannedTasks = tasks.length;
+        let todoTasks = 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({
+                    kind: "todo",
+                    targetAgentId,
+                    sessionRef,
+                    taskId: task.taskId,
+                    ok: result.ok,
+                    error: result.error,
+                });
+                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,
+                ok: result.ok,
+                error: result.error,
+            });
+        }
+        for (const candidate of inactiveCandidates) {
+            const sessionRef = buildInactiveSessionRef(candidate.managerAgentId, candidate.subjectAgentId);
+            const message = buildInactiveAgentMessage({
+                managerAgentId: candidate.managerAgentId,
+                subjectAgentId: candidate.subjectAgentId,
+                subjectName: candidate.subjectName,
+                role: candidate.role,
+                inactiveMinutes,
+                lastActionTimestamp: candidate.lastActionTimestamp,
+            });
+            const result = await this.dispatchAutomationMessage(paths, candidate.managerAgentId, sessionRef, message);
+            dispatches.push({
+                kind: "inactive",
+                targetAgentId: candidate.managerAgentId,
+                sessionRef,
+                subjectAgentId: candidate.subjectAgentId,
+                ok: result.ok,
+                error: result.error,
+            });
+        }
+        const failed = dispatches.filter((entry) => !entry.ok).length;
+        return {
+            ranAt,
+            scannedTasks,
+            todoTasks,
+            blockedTasks,
+            inactiveAgents: inactiveCandidates.length,
+            sent: dispatches.length - failed,
+            failed,
+            dispatches,
+        };
+    }
+    async listSkills(agentId = DEFAULT_AGENT_ID) {
+        const paths = this.pathsProvider.getPaths();
+        return this.skillService.listSkills(paths, agentId);
+    }
+    async listGlobalSkills() {
+        const paths = this.pathsProvider.getPaths();
+        return this.skillService.listGlobalSkills(paths);
+    }
+    async installSkill(request) {
+        const paths = this.pathsProvider.getPaths();
+        const result = await this.skillService.installSkill(paths, request);
+        if (result.scope === "agent" && result.agentId) {
+            await this.syncOpenClawRoleSkills(paths, result.agentId);
+        }
+        return result;
+    }
+    async runOpenClaw(args, options = {}) {
+        if (!this.commandRunner) {
+            throw new Error("OpenClaw passthrough is unavailable: command runner was not configured.");
+        }
+        const sanitized = args.map((value) => value.trim()).filter(Boolean);
+        if (sanitized.length === 0) {
+            throw new Error("OpenClaw passthrough requires at least one argument.");
+        }
+        const executionEnv = prepareOpenClawCommandEnv(options.env ?? process.env);
+        const command = executionEnv.OPENGOAT_OPENCLAW_CMD?.trim() ||
+            executionEnv.OPENCLAW_CMD?.trim() ||
+            process.env.OPENGOAT_OPENCLAW_CMD?.trim() ||
+            process.env.OPENCLAW_CMD?.trim() ||
+            "openclaw";
+        try {
+            return await this.commandRunner.run({
+                command,
+                args: sanitized,
+                cwd: options.cwd,
+                env: executionEnv,
+            });
+        }
+        catch (error) {
+            if (isSpawnPermissionOrMissing(error)) {
+                throw new ProviderCommandNotFoundError(OPENCLAW_PROVIDER_ID, command);
+            }
+            throw error;
+        }
     }
     async listSessions(agentId = DEFAULT_AGENT_ID, options = {}) {
         const paths = this.pathsProvider.getPaths();
         return this.sessionService.listSessions(paths, agentId, options);
     }
+    async prepareSession(agentId = DEFAULT_AGENT_ID, options = {}) {
+        const paths = this.pathsProvider.getPaths();
+        const prepared = await this.sessionService.prepareRunSession(paths, agentId, {
+            sessionRef: options.sessionRef,
+            projectPath: options.projectPath,
+            forceNew: options.forceNew,
+            userMessage: "",
+        });
+        if (!prepared.enabled) {
+            throw new Error("Session preparation was disabled.");
+        }
+        return prepared.info;
+    }
+    async getAgentLastAction(agentId = DEFAULT_AGENT_ID) {
+        const paths = this.pathsProvider.getPaths();
+        return this.sessionService.getLastAgentAction(paths, agentId);
+    }
     async getSessionHistory(agentId = DEFAULT_AGENT_ID, options = {}) {
         const paths = this.pathsProvider.getPaths();
         return this.sessionService.getSessionHistory(paths, agentId, options);
@@ -304,5 +673,506 @@ export class OpenGoatService {
     getPaths() {
         return this.pathsProvider.getPaths();
     }
+    async dispatchAutomationMessage(paths, agentId, sessionRef, message) {
+        try {
+            const result = await this.orchestrationService.runAgent(paths, agentId, {
+                message,
+                sessionRef,
+                env: process.env,
+            });
+            if (result.code !== 0) {
+                return {
+                    ok: false,
+                    error: (result.stderr ||
+                        result.stdout ||
+                        `Runtime exited with code ${result.code}.`).trim(),
+                };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: toErrorMessage(error),
+            };
+        }
+    }
+    resolveNowIso() {
+        return this.nowIso();
+    }
+    async initializeRuntimeDefaults() {
+        const initialization = await this.bootstrapService.initialize();
+        try {
+            await this.syncRuntimeDefaults();
+        }
+        catch {
+            // Startup remains functional even if OpenClaw CLI/runtime is unavailable.
+        }
+        return initialization;
+    }
+    resolveNowMs() {
+        return Date.now();
+    }
+    async syncOpenClawRoleSkills(paths, rawAgentId) {
+        const agentId = normalizeAgentId(rawAgentId);
+        if (!agentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const createdPaths = [];
+        const skippedPaths = [];
+        const removedPaths = [];
+        const managedSkillsSync = await this.removeOpenClawManagedRoleSkills(paths);
+        createdPaths.push(...managedSkillsSync.createdPaths);
+        skippedPaths.push(...managedSkillsSync.skippedPaths);
+        removedPaths.push(...managedSkillsSync.removedPaths);
+        const syncedAgents = new Set();
+        const syncAgent = async (targetAgentId) => {
+            if (syncedAgents.has(targetAgentId)) {
+                return;
+            }
+            syncedAgents.add(targetAgentId);
+            const sync = await this.agentService.ensureAgentWorkspaceRoleSkills(paths, targetAgentId);
+            createdPaths.push(...sync.createdPaths);
+            skippedPaths.push(...sync.skippedPaths);
+            removedPaths.push(...sync.removedPaths);
+        };
+        await syncAgent(agentId);
+        const manifest = await this.agentManifestService.getManifest(paths, agentId);
+        const managerAgentId = normalizeAgentId(manifest.metadata.reportsTo ?? "");
+        if (managerAgentId) {
+            await syncAgent(managerAgentId);
+        }
+        return {
+            createdPaths,
+            skippedPaths,
+            removedPaths,
+        };
+    }
+    async removeOpenClawManagedRoleSkills(paths) {
+        if (!this.commandRunner) {
+            return {
+                createdPaths: [],
+                skippedPaths: ["openclaw-managed-skills:command-runner-unavailable"],
+                removedPaths: [],
+            };
+        }
+        const managedSkillsDir = await this.resolveOpenClawManagedSkillsDir(paths);
+        if (!managedSkillsDir) {
+            return {
+                createdPaths: [],
+                skippedPaths: ["openclaw-managed-skills:unresolved"],
+                removedPaths: [],
+            };
+        }
+        const skippedPaths = [];
+        const removedPaths = [];
+        for (const legacySkillId of [
+            "board-manager",
+            "board-individual",
+            "og-board-manager",
+            "og-board-individual",
+            "manager",
+            "board-user",
+        ]) {
+            const legacyDir = this.pathPort.join(managedSkillsDir, legacySkillId);
+            if (!(await this.fileSystem.exists(legacyDir))) {
+                skippedPaths.push(legacyDir);
+                continue;
+            }
+            await this.fileSystem.removeDir(legacyDir);
+            removedPaths.push(legacyDir);
+        }
+        return {
+            createdPaths: [],
+            skippedPaths,
+            removedPaths,
+        };
+    }
+    async resolveOpenClawManagedSkillsDir(paths) {
+        if (this.openClawManagedSkillsDirCache !== undefined) {
+            return this.openClawManagedSkillsDirCache;
+        }
+        const providerConfig = await this.providerService.getProviderConfig(paths, OPENCLAW_PROVIDER_ID);
+        const env = {
+            ...process.env,
+            ...(providerConfig?.env ?? {}),
+        };
+        const skillsList = await this.runOpenClaw(["skills", "list", "--json"], {
+            env,
+        });
+        if (skillsList.code !== 0) {
+            throw new Error(`OpenClaw skills list failed (exit ${skillsList.code}). ${skillsList.stderr.trim() || skillsList.stdout.trim() || ""}`.trim());
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(skillsList.stdout);
+        }
+        catch {
+            throw new Error("OpenClaw skills list returned non-JSON output; cannot resolve managed skills directory.");
+        }
+        const managedSkillsDir = extractManagedSkillsDir(parsed);
+        this.openClawManagedSkillsDirCache = managedSkillsDir;
+        return managedSkillsDir;
+    }
+    async listOpenClawAgents(paths) {
+        if (!this.commandRunner) {
+            return [];
+        }
+        const env = await this.resolveOpenClawEnv(paths);
+        const listed = await this.runOpenClaw(["agents", "list", "--json"], {
+            env,
+        });
+        if (listed.code !== 0) {
+            throw new Error(`OpenClaw agents list failed (exit ${listed.code}). ${listed.stderr.trim() || listed.stdout.trim() || ""}`.trim());
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(listed.stdout);
+        }
+        catch {
+            throw new Error("OpenClaw agents list returned non-JSON output; cannot inspect agents.");
+        }
+        return extractOpenClawAgents(parsed);
+    }
+    async ensureOpenClawAgentLocation(paths, params) {
+        if (!this.commandRunner) {
+            return;
+        }
+        const env = await this.resolveOpenClawEnv(paths);
+        const listed = await this.runOpenClaw(["agents", "list", "--json"], {
+            env,
+        });
+        if (listed.code !== 0) {
+            throw new Error(`OpenClaw agents list failed (exit ${listed.code}). ${listed.stderr.trim() || listed.stdout.trim() || ""}`.trim());
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(listed.stdout);
+        }
+        catch {
+            throw new Error("OpenClaw agents list returned non-JSON output; cannot verify agent location.");
+        }
+        const entry = extractOpenClawAgentEntry(parsed, params.agentId);
+        if (!entry) {
+            return;
+        }
+        if (pathMatches(entry.workspace, params.workspaceDir) &&
+            pathMatches(entry.agentDir, params.internalConfigDir)) {
+            return;
+        }
+        const deleted = await this.providerService.deleteProviderAgent(paths, params.agentId, { providerId: OPENCLAW_PROVIDER_ID });
+        if (deleted.code !== 0) {
+            throw new Error(`OpenClaw agent location repair failed deleting "${params.agentId}" (exit ${deleted.code}). ${deleted.stderr.trim() || deleted.stdout.trim() || ""}`.trim());
+        }
+        const recreated = await this.providerService.createProviderAgent(paths, params.agentId, {
+            providerId: OPENCLAW_PROVIDER_ID,
+            displayName: params.displayName,
+            workspaceDir: params.workspaceDir,
+            internalConfigDir: params.internalConfigDir,
+        });
+        if (recreated.code !== 0 &&
+            !containsAlreadyExistsMessage(recreated.stdout, recreated.stderr)) {
+            throw new Error(`OpenClaw agent location repair failed creating "${params.agentId}" (exit ${recreated.code}). ${recreated.stderr.trim() || recreated.stdout.trim() || ""}`.trim());
+        }
+    }
+    async resolveOpenClawEnv(paths) {
+        const providerConfig = await this.providerService.getProviderConfig(paths, OPENCLAW_PROVIDER_ID);
+        return {
+            ...(providerConfig?.env ?? {}),
+            ...process.env,
+        };
+    }
+    async collectInactiveAgents(paths, manifests, inactiveMinutes) {
+        const nowMs = this.resolveNowMs();
+        const inactiveCutoffMs = nowMs - inactiveMinutes * 60_000;
+        const inactive = [];
+        for (const manifest of manifests) {
+            const managerAgentId = normalizeAgentId(manifest.metadata.reportsTo ?? "");
+            if (!managerAgentId) {
+                continue;
+            }
+            const lastAction = await this.sessionService.getLastAgentAction(paths, manifest.agentId);
+            if (lastAction && lastAction.timestamp >= inactiveCutoffMs) {
+                continue;
+            }
+            inactive.push({
+                managerAgentId,
+                subjectAgentId: manifest.agentId,
+                subjectName: manifest.metadata.name,
+                role: manifest.metadata.description,
+                lastActionTimestamp: lastAction?.timestamp,
+            });
+        }
+        return inactive;
+    }
+}
+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;
+    }
+    return String(error);
+}
+function resolveInactiveMinutes(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return 30;
+    }
+    return Math.floor(value);
+}
+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) {
+        return false;
+    }
+    return leftNormalized === rightNormalized;
+}
+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;
+    }
+    return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function normalizePathForCompare(value) {
+    const trimmed = value.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()
+        : "No recorded assistant actions yet";
+    return [
+        `Your reportee "@${params.subjectAgentId}" (${params.subjectName}) has no activity in the last ${params.inactiveMinutes} minutes.`,
+        `Role: ${params.role}`,
+        `Last action: ${lastAction}`,
+        `Manager: @${params.managerAgentId}`,
+        "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) {
+            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;
+        }
+        visited.add(current);
+        queue.push(...(byManager.get(current) ?? []));
+    }
+    return [...visited].sort((left, right) => left.localeCompare(right));
+}
+function prepareOpenClawCommandEnv(env) {
+    const mergedPath = dedupePathEntries([
+        ...resolvePreferredOpenClawCommandPaths(env),
+        ...(env.PATH?.split(path.delimiter) ?? []),
+    ]);
+    return {
+        ...env,
+        PATH: mergedPath.join(path.delimiter),
+    };
+}
+function resolvePreferredOpenClawCommandPaths(env) {
+    const homeDir = homedir();
+    const preferredPaths = [
+        path.dirname(process.execPath),
+        path.join(homeDir, ".npm-global", "bin"),
+        path.join(homeDir, ".npm", "bin"),
+        path.join(homeDir, ".local", "bin"),
+        path.join(homeDir, ".volta", "bin"),
+        path.join(homeDir, ".fnm", "current", "bin"),
+        path.join(homeDir, ".asdf", "shims"),
+        path.join(homeDir, "bin"),
+    ];
+    const npmPrefixCandidates = dedupePathEntries([
+        env.npm_config_prefix ?? "",
+        env.NPM_CONFIG_PREFIX ?? "",
+        process.env.npm_config_prefix ?? "",
+        process.env.NPM_CONFIG_PREFIX ?? "",
+    ]);
+    for (const prefix of npmPrefixCandidates) {
+        preferredPaths.push(path.join(prefix, "bin"));
+    }
+    if (process.platform === "darwin") {
+        preferredPaths.push("/opt/homebrew/bin", "/opt/homebrew/opt/node@22/bin", "/usr/local/opt/node@22/bin");
+    }
+    return preferredPaths;
+}
+function dedupePathEntries(entries) {
+    const seen = new Set();
+    const deduped = [];
+    for (const rawEntry of entries) {
+        const entry = rawEntry.trim();
+        if (!entry || seen.has(entry)) {
+            continue;
+        }
+        seen.add(entry);
+        deduped.push(entry);
+    }
+    return deduped;
+}
+function isSpawnPermissionOrMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        ((error.code ?? "") === "ENOENT" ||
+            (error.code ?? "") === "EACCES"));
 }
 //# sourceMappingURL=opengoat.service.js.map