@akira-tl/forgerelay 0.8.5 → 0.8.7

package/dist/remote-workspace-relay.js

@@ -2,7 +2,8 @@ import { randomBytes } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, withRemoteMcpClient, } from "./remote-auth.js";
+import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, } from "./remote-auth.js";
+import { RemoteMcpConnectionPool } from "./remote-mcp-connection-pool.js";
 import { withRemoteServiceEndpoint } from "./remote-transport.js";
 import { loadForgeRelayFiles, writeForgeRelayRemote, } from "./user-config.js";
 const ROUTE_LOCK_RETRY_MS = 10;
@@ -15,6 +16,7 @@ export class RemoteWorkspaceRelay {
     authEnv;
     routeStateDir;
     routeStatePath;
+    mcpConnections = new RemoteMcpConnectionPool();
     constructor(configDir, stateDir) {
         this.authEnv = { FORGERELAY_CONFIG_DIR: configDir };
         this.routeStateDir = stateDir;
@@ -27,6 +29,9 @@ export class RemoteWorkspaceRelay {
         this.loadRoutes();
         return this.routes.has(workspaceId);
     }
+    async shutdown() {
+        await this.mcpConnections.closeAll();
+    }
     async inspectWorkspace(gatewayWorkspaceId) {
         const route = this.requireRoute(gatewayWorkspaceId);
         const resolved = this.remoteByInstance(route.remoteInstanceId);
@@ -235,11 +240,14 @@ export class RemoteWorkspaceRelay {
             throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
         }
     }
+    async activityIndex(turnId, knownRevision, conversationScopeId) {
+        return this.callTurnTool(turnId, "activity_index", { turnId, ...(knownRevision !== undefined ? { knownRevision } : {}) }, conversationScopeId);
+    }
     async activityDetail(turnId, activityId, conversationScopeId) {
         return this.callTurnTool(turnId, "activity_detail", { turnId, activityId }, conversationScopeId);
     }
-    async activityOutput(turnId, outputId, conversationScopeId) {
-        return this.callTurnTool(turnId, "activity_output", { turnId, outputId }, conversationScopeId);
+    async activityOutput(turnId, outputId, conversationScopeId, cursor) {
+        return this.callTurnTool(turnId, "activity_output", { turnId, outputId, ...(cursor !== undefined ? { cursor } : {}) }, conversationScopeId);
     }
     async callTurnTool(turnId, name, args, conversationScopeId) {
         const gatewayWorkspaceId = this.turnRoutes.get(turnId);
@@ -464,31 +472,53 @@ export class RemoteWorkspaceRelay {
         return { alias: entry[0], remote: entry[1] };
     }
     async callRemoteTool(alias, initialRemote, name, args, conversationScopeId) {
-        return withRemoteServiceEndpoint(initialRemote.target, initialRemote.sshRoute, async (endpoint) => {
-            let remote = initialRemote;
-            let refreshed = false;
-            if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
-                remote = await this.refreshRemote(alias, remote, endpoint);
+        let remote = initialRemote;
+        let refreshed = false;
+        if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
+            remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
+            refreshed = true;
+        }
+        let connection;
+        try {
+            connection = await this.mcpConnections.get(remote);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
                 refreshed = true;
+                connection = await this.mcpConnections.get(remote);
             }
-            const invoke = () => withRemoteMcpClient(remote, endpoint, async (client) => CallToolResultSchema.parse(await client.callTool({
-                name,
-                arguments: args,
-                ...(conversationScopeId
-                    ? { _meta: { "openai/session": conversationScopeId } }
-                    : {}),
-            })));
-            try {
-                return await invoke();
+            else {
+                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-            catch (error) {
-                if (!refreshed && isRemoteMcpUnauthorized(error)) {
-                    remote = await this.refreshRemote(alias, remote, endpoint);
-                    return invoke();
+        }
+        const invoke = async (active) => CallToolResultSchema.parse(await active.client.callTool({
+            name,
+            arguments: args,
+            ...(conversationScopeId
+                ? { _meta: { "openai/session": conversationScopeId } }
+                : {}),
+        }));
+        try {
+            return await invoke(connection);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await this.refreshRemote(alias, remote, connection.endpoint);
+                refreshed = true;
+                await this.mcpConnections.invalidate(remote.instanceId, connection);
+                const refreshedConnection = await this.mcpConnections.get(remote);
+                try {
+                    return await invoke(refreshedConnection);
+                }
+                catch (retryError) {
+                    await this.mcpConnections.invalidate(remote.instanceId, refreshedConnection);
+                    throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(retryError)}`, { cause: retryError });
                 }
-                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-        });
+            await this.mcpConnections.invalidate(remote.instanceId, connection);
+            throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
+        }
     }
     async refreshRemote(alias, remote, endpoint) {
         const refreshed = await refreshRemoteAuthentication(remote, endpoint);

package/dist/server.js

@@ -55,7 +55,8 @@ import { formatPathForPrompt } from "./skills.js";
 import { createWorkspaceStore } from "./workspace-store.js";
 import { WorkspaceTaskReminderTracker } from "./workspace-task-reminders.js";
 import { WorkspaceTaskStore } from "./workspace-tasks.js";
-import { formatAgentsPath, WorkspaceRegistry } from "./workspaces.js";
+import { compactWorkspacePresentation } from "./workspace-presentation.js";
+import { formatAgentsPath, WorkspaceRegistry, } from "./workspaces.js";
 import { formatAvailableSubagentProfile, summarizeSubagentProfile } from "./subagents/profiles.js";
 import { formatSubagentProviderAvailabilitySummary, formatUnavailableSubagentProvider, getSubagentProviderAvailabilitySnapshot, } from "./subagents/providers/availability.js";
 import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from "./subagents/sessions/mcp/audit.js";
@@ -1342,6 +1343,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
 }
 export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, options = {}) {
     const connectionScopeId = `mcp-connection:${randomUUID()}`;
+    const ownsRemoteWorkspaces = options.remoteWorkspaces === undefined;
     const remoteWorkspaces = options.remoteWorkspaces
         ?? new RemoteWorkspaceRelay(config.configDir, config.stateDir);
     const compositeWorkspaces = options.compositeWorkspaces
@@ -1564,6 +1566,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 providerUnavailableReason: availability?.reason,
             };
         });
+        const bootstrapComponents = new Set(opened.bootstrapContextComponents);
         return {
             member: memberName,
             workspaceId: compositeWorkspaceId,
@@ -1573,16 +1576,13 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             capabilityFingerprint,
             capabilityCatalog,
             includeBootstrapContext: opened.includeBootstrapContext,
-            ...(opened.includeBootstrapContext
-                ? {
-                    capabilityGuides,
-                    agentsFiles,
-                    availableAgentsFiles,
-                    skills,
-                    agentProviders,
-                    agents,
-                    skillDiagnostics: redactSkillDiagnosticPaths(workspace.skillDiagnostics),
-                }
+            ...(bootstrapComponents.has("capabilityGuides") ? { capabilityGuides } : {}),
+            ...(bootstrapComponents.has("agentsFiles") ? { agentsFiles } : {}),
+            ...(bootstrapComponents.has("availableAgentsFiles") ? { availableAgentsFiles } : {}),
+            ...(bootstrapComponents.has("skills") ? { skills } : {}),
+            ...(bootstrapComponents.has("agentProfiles") ? { agentProviders, agents } : {}),
+            ...(bootstrapComponents.has("skillDiagnostics")
+                ? { skillDiagnostics: redactSkillDiagnosticPaths(workspace.skillDiagnostics) }
                 : {}),
             instruction: opened.includeBootstrapContext
                 ? `Bootstrap context for Composite member ${memberName}. Keep using Composite workspaceId ${compositeWorkspaceId} and pass member=${memberName} for work operations.`
@@ -2107,19 +2107,21 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const workspacePanelStates = new Map();
     const workspacePanelState = (workspaceId) => {
         const remembered = workspacePanelStates.get(workspaceId);
-        if (remembered)
+        if (remoteWorkspaces.has(workspaceId) || compositeWorkspaces.has(workspaceId)) {
             return remembered;
+        }
         try {
             const workspace = workspaces.getWorkspace(workspaceId);
-            return {
+            if (remembered)
+                return remembered;
+            return compactWorkspacePresentation({
                 workspaceId: workspace.id,
                 root: workspace.root,
                 path: workspace.root,
                 mode: workspace.mode,
                 sourceRoot: workspace.sourceRoot,
-                instruction: `Use workspaceId ${workspace.id} for subsequent calls.`,
                 summary: { mode: workspace.mode },
-            };
+            });
         }
         catch {
             return undefined;
@@ -2132,7 +2134,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const card = meta.card;
         if (meta.tool !== toolNames.openWorkspace || typeof card !== "object" || card === null)
             return;
-        workspacePanelStates.set(workspaceId, card);
+        const compact = compactWorkspacePresentation(card);
+        workspacePanelStates.set(workspaceId, {
+            ...(workspacePanelStates.get(workspaceId) ?? {}),
+            ...compact,
+        });
     };
     const workspaceAppResourceMetadata = {
         description: "Historical ForgeRelay tool card UI.",
@@ -2880,7 +2886,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             rememberWorkspacePanelState(opened.workspaceId, response);
             return response;
         }
-        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
+        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, bootstrapContextComponents, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
             conversationScopeId,
             protectedWorkspaceIds,
         });
@@ -2926,15 +2932,18 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const cardAvailableAgentsFiles = availableAgentsFiles.map((file) => ({
             path: formatAgentsPath(file.path, workspace.root),
         }));
-        const visibleSkills = includeBootstrapContext ? cardSkills : [];
-        const visibleSkillDiagnostics = includeBootstrapContext
+        const bootstrapComponents = new Set(bootstrapContextComponents);
+        const visibleSkills = bootstrapComponents.has("skills") ? cardSkills : [];
+        const visibleSkillDiagnostics = bootstrapComponents.has("skillDiagnostics")
             ? redactSkillDiagnosticPaths(workspace.skillDiagnostics)
             : [];
-        const visibleCapabilityGuides = includeBootstrapContext ? capabilityGuides : [];
-        const visibleAgentProviders = includeBootstrapContext ? cardAgentProviders : [];
-        const visibleAgents = includeBootstrapContext ? cardAgents : [];
-        const loadedAgentsFiles = includeBootstrapContext ? cardAgentsFiles : [];
-        const availableAgentsFileOutputs = includeBootstrapContext ? cardAvailableAgentsFiles : [];
+        const visibleCapabilityGuides = bootstrapComponents.has("capabilityGuides") ? capabilityGuides : [];
+        const visibleAgentProviders = bootstrapComponents.has("agentProfiles") ? cardAgentProviders : [];
+        const visibleAgents = bootstrapComponents.has("agentProfiles") ? cardAgents : [];
+        const loadedAgentsFiles = bootstrapComponents.has("agentsFiles") ? cardAgentsFiles : [];
+        const availableAgentsFileOutputs = bootstrapComponents.has("availableAgentsFiles")
+            ? cardAvailableAgentsFiles
+            : [];
         const workspaceContextInstruction = "For later open_workspace calls, context=\"auto\" avoids repeating unchanged bootstrap context; use context=\"none\" when only the workspace handle/metadata is needed, or context=\"full\" to force a refresh.";
         const workspaceManagementInstruction = "Use open_workspace(action=\"list\") for lightweight Workspace inventory. Use action=\"inspect\" with one known workspaceId for bounded read-only metadata without opening/resuming it. Explicitly open a Workspace before executing or mutating against it, and ask the user before close_workspace cleanup.";
         const cardInstruction = config.skillsEnabled
@@ -2945,7 +2954,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 ? [
                     `Workspace already exists as ${workspace.id} for this directory.`,
                     "Reuse this workspaceId for subsequent tool calls.",
-                    "The complete project context is included because it has not yet been provided in this conversation or host context.",
+                    `Project bootstrap context components included in this response: ${bootstrapContextComponents.join(", ")}. Components not listed are unchanged and are not repeated.`,
                     workspaceContextInstruction,
                     workspaceManagementInstruction,
                 ].join("\n\n")
@@ -3012,41 +3021,44 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             success: true,
             durationMs: Math.round(performance.now() - startedAt),
         });
+        const workspaceCard = {
+            workspaceId: workspace.id,
+            kind: "workspace",
+            root: workspace.root,
+            path: workspace.root,
+            mode: workspace.mode,
+            workspaceReused,
+            includeBootstrapContext,
+            sourceRoot: workspace.sourceRoot,
+            worktree: workspace.worktree,
+            worktrees: knownWorktrees,
+            staleWorkspaces,
+            capabilityFingerprint,
+            contextFingerprint,
+            capabilityCatalog,
+            agentsFiles: cardAgentsFiles,
+            availableAgentsFiles: cardAvailableAgentsFiles,
+            skills: cardSkills,
+            agentProviders: cardAgentProviders,
+            agents: cardAgents,
+            instruction: cardInstruction,
+            summary: {
+                mode: workspace.mode,
+                agentsFiles: cardAgentsFiles.length,
+                availableAgentsFiles: cardAvailableAgentsFiles.length,
+                skills: cardSkills.length,
+                capabilities: capabilityCatalog.length,
+                agentProviders: cardAgentProviders.length,
+                agents: cardAgents.length,
+            },
+        };
         const response = hooks.decorateResult(workspace.id, attachHookReports({
             content: resultContent,
             _meta: {
                 tool: "open_workspace",
-                card: {
-                    workspaceId: workspace.id,
-                    kind: "workspace",
-                    root: workspace.root,
-                    path: workspace.root,
-                    mode: workspace.mode,
-                    workspaceReused,
-                    includeBootstrapContext,
-                    sourceRoot: workspace.sourceRoot,
-                    worktree: workspace.worktree,
-                    worktrees: knownWorktrees,
-                    staleWorkspaces,
-                    capabilityFingerprint,
-                    contextFingerprint,
-                    capabilityCatalog,
-                    agentsFiles: cardAgentsFiles,
-                    availableAgentsFiles: cardAvailableAgentsFiles,
-                    skills: cardSkills,
-                    agentProviders: cardAgentProviders,
-                    agents: cardAgents,
-                    instruction: cardInstruction,
-                    summary: {
-                        mode: workspace.mode,
-                        agentsFiles: cardAgentsFiles.length,
-                        availableAgentsFiles: cardAvailableAgentsFiles.length,
-                        skills: cardSkills.length,
-                        capabilities: capabilityCatalog.length,
-                        agentProviders: cardAgentProviders.length,
-                        agents: cardAgents.length,
-                    },
-                },
+                card: includeBootstrapContext
+                    ? workspaceCard
+                    : compactWorkspacePresentation(workspaceCard),
             },
             structuredContent: {
                 action: "open",
@@ -3061,16 +3073,19 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 capabilityFingerprint,
                 contextFingerprint,
                 capabilityCatalog,
-                ...(includeBootstrapContext
-                    ? {
-                        capabilityGuides: visibleCapabilityGuides,
-                        agentsFiles: loadedAgentsFiles,
-                        availableAgentsFiles: availableAgentsFileOutputs,
-                        skills: visibleSkills,
-                        agentProviders: visibleAgentProviders,
-                        agents: visibleAgents,
-                        skillDiagnostics: visibleSkillDiagnostics,
-                    }
+                ...(bootstrapComponents.has("capabilityGuides")
+                    ? { capabilityGuides: visibleCapabilityGuides }
+                    : {}),
+                ...(bootstrapComponents.has("agentsFiles") ? { agentsFiles: loadedAgentsFiles } : {}),
+                ...(bootstrapComponents.has("availableAgentsFiles")
+                    ? { availableAgentsFiles: availableAgentsFileOutputs }
+                    : {}),
+                ...(bootstrapComponents.has("skills") ? { skills: visibleSkills } : {}),
+                ...(bootstrapComponents.has("agentProfiles")
+                    ? { agentProviders: visibleAgentProviders, agents: visibleAgents }
+                    : {}),
+                ...(bootstrapComponents.has("skillDiagnostics")
+                    ? { skillDiagnostics: visibleSkillDiagnostics }
                     : {}),
                 instruction,
             },
@@ -3098,13 +3113,17 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             }
             return remoteWorkspaces.activitySnapshot(input, conversationScopeId);
         },
+        index: async (turnId, knownRevision, conversationScopeId) => {
+            const composite = await compositeActivity.index(turnId, knownRevision);
+            return composite ?? remoteWorkspaces.activityIndex(turnId, knownRevision, conversationScopeId);
+        },
         detail: async (turnId, activityId, conversationScopeId) => {
             const composite = await compositeActivity.detail(turnId, activityId);
             return composite ?? remoteWorkspaces.activityDetail(turnId, activityId, conversationScopeId);
         },
-        output: async (turnId, outputId, conversationScopeId) => {
-            const composite = await compositeActivity.output(turnId, outputId);
-            return composite ?? remoteWorkspaces.activityOutput(turnId, outputId, conversationScopeId);
+        output: async (turnId, outputId, conversationScopeId, cursor) => {
+            const composite = await compositeActivity.output(turnId, outputId, cursor);
+            return composite ?? remoteWorkspaces.activityOutput(turnId, outputId, conversationScopeId, cursor);
         },
     });
     registerAppTool(server, toolNames.capability, {
@@ -4082,7 +4101,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .min(0)
                     .max(300_000)
                     .optional()
-                    .describe("Feedback window before returning. For action=run, use 0 for immediate background handoff; otherwise defaults to 10000ms. For action=process, polling defaults to 5000ms and interaction to 250ms."),
+                    .describe("Maximum feedback wait, not a minimum delay: if the process finishes sooner, the call returns immediately. For long-running commands or wait-only action=process calls, set a long window near the Host request deadline (60000ms when supported) instead of repeated short polling. For action=run, use 0 for immediate background handoff; otherwise defaults to 10000ms. For action=process, wait-only calls default to 5000ms and interaction to 250ms."),
                 timeoutMs: z
                     .number()
                     .int()
@@ -4232,6 +4251,21 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         writeStdinRemote: (workspaceId, input, conversationScopeId) => remoteWorkspaces.writeStdin(workspaceId, input, conversationScopeId),
         hostScopeIdFor,
     });
+    if (ownsRemoteWorkspaces) {
+        const closeServer = server.close.bind(server);
+        let closePromise;
+        server.close = () => {
+            closePromise ??= (async () => {
+                try {
+                    await closeServer();
+                }
+                finally {
+                    await remoteWorkspaces.shutdown();
+                }
+            })();
+            return closePromise;
+        };
+    }
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {
@@ -4488,6 +4522,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 clearInterval(transportCleanupTimer);
                 const results = await transports.closeAll();
                 logTransportCloseResults("server_shutdown", results);
+                await sharedRemoteWorkspaces.shutdown();
                 processSessions.shutdown();
                 await codeIntelligence.shutdown();
                 oauthProvider.close();

package/dist/skills.js

@@ -9,7 +9,7 @@ export function effectiveSkillPaths(config, cwd) {
     const defaultPathCandidates = [
         join(homedir(), ".agents", "skills"),
         resolve(cwd, ".agents", "skills"),
-        config.devspaceSkillsDir,
+        config.configSkillsDir,
         join(config.agentDir, "skills"),
     ];
     const defaultPaths = defaultPathCandidates.filter((path) => path !== undefined && existsSync(path));

package/dist/subagents/profiles.js

@@ -16,8 +16,7 @@ export async function loadSubagentProfiles(config, workspaceRoot) {
     if (!config.subagents)
         return [];
     const profileDirs = [
-        config.devspaceAgentsDir,
-        join(workspaceRoot, ".devspace", "agents"),
+        config.configAgentsDir,
         join(workspaceRoot, ".forgerelay", "agents"),
     ];
     const profilesByName = new Map();

package/dist/subagents/providers/adapters/pi.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { removeDevspaceNodeModulesBinFromPath } from "../path.js";
+import { removeForgeRelayNodeModulesBinFromPath } from "../path.js";
 import { asRecord, assertPipedChild, errorMessage, readArray, readNestedString, requireFinalResponse, terminateChildOnAbort, unwrapProviderPayload, } from "../shared.js";
 const PI_AGENT_TIMEOUT_MS = 120_000;
 export class PiRpcSubagentAdapter {
@@ -69,7 +69,7 @@ export function piCommandEnvironment(env) {
         return env;
     return {
         ...env,
-        PATH: removeDevspaceNodeModulesBinFromPath(path),
+        PATH: removeForgeRelayNodeModulesBinFromPath(path),
     };
 }
 class JsonLineRpc {

package/dist/subagents/providers/availability.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { delimiter, resolve } from "node:path";
 import { subagentProviderContinuationSupported } from "./continuation.js";
-import { removeDevspaceNodeModulesBinFromPath } from "./path.js";
+import { removeForgeRelayNodeModulesBinFromPath } from "./path.js";
 import { SUBAGENT_PROVIDERS, } from "../profiles.js";
 export function getSubagentProviderAvailabilitySnapshot(env = process.env) {
     return SUBAGENT_PROVIDERS.map((provider) => checkSubagentProviderAvailability(provider, env));
@@ -128,6 +128,6 @@ function piAvailabilityEnvironment(env) {
         return env;
     return {
         ...env,
-        PATH: removeDevspaceNodeModulesBinFromPath(path),
+        PATH: removeForgeRelayNodeModulesBinFromPath(path),
     };
 }

package/dist/subagents/providers/path.js

@@ -1,12 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { delimiter, resolve, sep } from "node:path";
-export function removeDevspaceNodeModulesBinFromPath(pathValue) {
+export function removeForgeRelayNodeModulesBinFromPath(pathValue) {
     return pathValue
         .split(delimiter)
-        .filter((entry) => entry && !isDevspaceNodeModulesBin(entry))
+        .filter((entry) => entry && !isForgeRelayNodeModulesBin(entry))
         .join(delimiter);
 }
-function isDevspaceNodeModulesBin(pathEntry) {
+function isForgeRelayNodeModulesBin(pathEntry) {
     const resolvedEntry = resolve(pathEntry);
     if (!resolvedEntry.endsWith(`${sep}node_modules${sep}.bin`)) {
         return false;
@@ -17,7 +17,7 @@ function isDevspaceNodeModulesBin(pathEntry) {
     try {
         const packageInfo = JSON.parse(readFileSync(packageJson, "utf8"));
         const packageName = typeof packageInfo.name === "string" ? packageInfo.name : "";
-        return ["@akira-tl/forgerelay", "@akira-tl/devspace", "@waishnav/devspace"].includes(packageName);
+        return packageName === "@akira-tl/forgerelay";
     }
     catch {
         return false;

package/dist/ui/.vite/manifest.json

@@ -2123,12 +2123,12 @@
       "_chunk-EyZ2wyi3.js"
     ]
   },
-  "_scrollbar-C2twAENW.js": {
-    "file": "assets/scrollbar-C2twAENW.js",
+  "_scrollbar-CbhpdW05.js": {
+    "file": "assets/scrollbar-CbhpdW05.js",
     "name": "scrollbar",
     "imports": [
       "_chunk-EyZ2wyi3.js",
-      "_workspace-app-CwbJnb_w.js"
+      "_workspace-app-CxwJuZyS.js"
     ],
     "dynamicImports": [
       "../../node_modules/@shikijs/langs/dist/abap.mjs",
@@ -2474,33 +2474,33 @@
       "_chunk-EyZ2wyi3.js"
     ]
   },
-  "_workspace-app-BztEvZIC.js": {
-    "file": "assets/workspace-app-BztEvZIC.js",
+  "_workspace-app-CxwJuZyS.js": {
+    "file": "assets/workspace-app-CxwJuZyS.js",
     "name": "workspace-app",
     "imports": [
-      "_workspace-app-CwbJnb_w.js"
+      "_chunk-EyZ2wyi3.js"
     ],
     "dynamicImports": [
-      "heavy-payload.tsx",
-      "review-payload.tsx"
+      "_workspace-app-CxwJuZyS.js"
+    ],
+    "css": [
+      "assets/workspace-app-ldjBmCJR.css"
     ]
   },
-  "_workspace-app-CwbJnb_w.js": {
-    "file": "assets/workspace-app-CwbJnb_w.js",
+  "_workspace-app-D6UR0AFl.js": {
+    "file": "assets/workspace-app-D6UR0AFl.js",
     "name": "workspace-app",
     "imports": [
-      "_chunk-EyZ2wyi3.js"
+      "_workspace-app-CxwJuZyS.js"
     ],
     "dynamicImports": [
-      "_workspace-app-CwbJnb_w.js"
-    ],
-    "css": [
-      "assets/workspace-app-YnUST8IP.css"
+      "heavy-payload.tsx",
+      "review-payload.tsx"
     ]
   },
-  "_workspace-app-YnUST8IP.css": {
-    "file": "assets/workspace-app-YnUST8IP.css",
-    "src": "_workspace-app-YnUST8IP.css"
+  "_workspace-app-ldjBmCJR.css": {
+    "file": "assets/workspace-app-ldjBmCJR.css",
+    "src": "_workspace-app-ldjBmCJR.css"
   },
   "_xml-JnmX6vyS.js": {
     "file": "assets/xml-JnmX6vyS.js",
@@ -2518,52 +2518,52 @@
     ]
   },
   "activity-panel-app.html": {
-    "file": "assets/activity-panel-app-E1ju2dqI.js",
+    "file": "assets/activity-panel-app-CUAN6zyW.js",
     "name": "activity-panel-app",
     "src": "activity-panel-app.html",
     "isEntry": true,
     "imports": [
-      "_workspace-app-CwbJnb_w.js"
+      "_workspace-app-CxwJuZyS.js"
     ]
   },
   "heavy-payload.tsx": {
-    "file": "assets/heavy-payload-CeW-n9w5.js",
+    "file": "assets/heavy-payload-CgzrutLm.js",
     "name": "heavy-payload",
     "src": "heavy-payload.tsx",
     "isDynamicEntry": true,
     "imports": [
-      "_scrollbar-C2twAENW.js",
-      "_workspace-app-BztEvZIC.js"
+      "_scrollbar-CbhpdW05.js",
+      "_workspace-app-D6UR0AFl.js"
     ]
   },
   "review-payload.tsx": {
-    "file": "assets/review-payload-B9CO298v.js",
+    "file": "assets/review-payload-BrLbezbq.js",
     "name": "review-payload",
     "src": "review-payload.tsx",
     "isDynamicEntry": true,
     "imports": [
-      "_scrollbar-C2twAENW.js",
-      "_workspace-app-BztEvZIC.js"
+      "_scrollbar-CbhpdW05.js",
+      "_workspace-app-D6UR0AFl.js"
     ]
   },
   "workspace-app.html": {
-    "file": "assets/workspace-app-rKuhdae8.js",
+    "file": "assets/workspace-app-Bhj96tsR.js",
     "name": "workspace-app",
     "src": "workspace-app.html",
     "isEntry": true,
     "imports": [
-      "_workspace-app-CwbJnb_w.js",
-      "_workspace-app-BztEvZIC.js"
+      "_workspace-app-CxwJuZyS.js",
+      "_workspace-app-D6UR0AFl.js"
     ]
   },
   "workspace-lifecycle-app.html": {
-    "file": "assets/workspace-lifecycle-app-CEfMdudP.js",
+    "file": "assets/workspace-lifecycle-app-Cqfhx9pV.js",
     "name": "workspace-lifecycle-app",
     "src": "workspace-lifecycle-app.html",
     "isEntry": true,
     "imports": [
-      "_workspace-app-CwbJnb_w.js",
-      "_workspace-app-BztEvZIC.js"
+      "_workspace-app-CxwJuZyS.js",
+      "_workspace-app-D6UR0AFl.js"
     ]
   }
 }

package/dist/ui/activity-panel-app.html

@@ -4,10 +4,10 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ForgeRelay Panel</title>
-    <script type="module" crossorigin src="./assets/activity-panel-app-E1ju2dqI.js"></script>
+    <script type="module" crossorigin src="./assets/activity-panel-app-CUAN6zyW.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/chunk-EyZ2wyi3.js">
-    <link rel="modulepreload" crossorigin href="./assets/workspace-app-CwbJnb_w.js">
-    <link rel="stylesheet" crossorigin href="./assets/workspace-app-YnUST8IP.css">
+    <link rel="modulepreload" crossorigin href="./assets/workspace-app-CxwJuZyS.js">
+    <link rel="stylesheet" crossorigin href="./assets/workspace-app-ldjBmCJR.css">
   </head>
   <body>
     <main id="app" class="shell">