@akira-tl/forgerelay 0.8.9 → 0.8.10

package/dist/mcp/server/operations/runtime/filesystem-tools.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { isAbsolute } from "node:path";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
 import { applyPatch } from "../../../filesystem/apply-patch.js";
+import { readFileTool } from "../../../filesystem/filesystem-tools.js";
 import { toolNames } from "../../../server-instructions.js";
 import { executeBulkRead } from "../../../operations/bulk-read.js";
 import { formatPathForPrompt } from "../../../../workspaces/resources/skills.js";
@@ -10,6 +12,7 @@ import { activityRelationFor, activityRequestFor, runActivityTool, runActivityTo
 import { workspaceHookInvocation } from "../../core/capability-support.js";
 import { resultOutputSchema, workspaceAgentsFileOutputSchema } from "../../core/schemas.js";
 import { contentText, logToolCall, textBlock, toolResultAgentsFiles, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
+import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 const WRITE_TOOL_ANNOTATIONS = {
     readOnlyHint: false,
     destructiveHint: true,
@@ -23,14 +26,15 @@ const EDIT_TOOL_ANNOTATIONS = {
     openWorldHint: false,
 };
 export function registerFilesystemTools(options) {
-    const { server, config, workspaces, compositeWorkspaces, compositeTaskGuides, remoteWorkspaces, coreOperations, nativeBulkMutations, activityLifecycle, hooks, toolDescriptions, resolveExecutionTarget, prepareExecutionContext, presentSemanticWorkResult, hostScopeIdFor, } = options;
+    const { server, config, workspaces, compositeWorkspaces, compositeTaskGuides, remoteWorkspaces, coreOperations, nativeBulkMutations, activityLifecycle, codeIntelligence, hooks, toolDescriptions, resolveExecutionTarget, prepareExecutionContext, presentSemanticWorkResult, hostScopeIdFor, } = options;
     registerAppTool(server, toolNames.read, {
         title: "Read file",
         description: toolDescriptions.read,
         inputSchema: {
             workspaceId: z
                 .string()
-                .describe("Workspace identifier returned by open_workspace."),
+                .optional()
+                .describe("Workspace identifier returned by open_workspace. Omit only for read-only inspection of absolute paths already inside configured allowedRoots."),
             member: z
                 .string()
                 .optional()
@@ -76,6 +80,54 @@ export function registerFilesystemTools(options) {
         if ((path === undefined) === (paths === undefined)) {
             throw new Error("read requires exactly one of path or paths.");
         }
+        if (workspaceId === undefined) {
+            if (member !== undefined)
+                throw new Error("read without workspaceId does not accept member.");
+            const requestedPaths = path !== undefined ? [path] : paths;
+            for (const requestedPath of requestedPaths) {
+                if (!isAbsolute(requestedPath)) {
+                    throw new Error("read without workspaceId requires absolute paths inside configured allowedRoots.");
+                }
+            }
+            const startedAt = performance.now();
+            const children = await Promise.all(requestedPaths.map(async (requestedPath) => {
+                const response = await readFileTool({ path: requestedPath, offset, limit }, {
+                    cwd: process.cwd(),
+                    root: config.allowedRoots[0] ?? process.cwd(),
+                    readRoots: config.allowedRoots,
+                });
+                return {
+                    path: requestedPath,
+                    status: response.isError ? "error" : "done",
+                    response,
+                    result: contentText(response.content),
+                };
+            }));
+            const failed = children.filter((child) => child.status === "error").length;
+            const content = children.flatMap((child) => requestedPaths.length === 1
+                ? child.response.content
+                : [textBlock(`--- ${child.path} · ${child.status} ---`), ...child.response.content]);
+            logToolCall(config, {
+                tool: toolNames.read,
+                path: requestedPaths.length === 1 ? requestedPaths[0] : `${requestedPaths.length} unscoped files`,
+                success: failed === 0,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content,
+                ...(failed > 0 ? { isError: true } : {}),
+                structuredContent: {
+                    result: contentText(content),
+                    ...(requestedPaths.length > 1
+                        ? {
+                            results: children.map(({ path: childPath, status, result }) => ({ path: childPath, status, result })),
+                            files: children.length,
+                            failed,
+                        }
+                        : {}),
+                },
+            };
+        }
         if (compositeWorkspaces.has(workspaceId) && member === undefined && path !== undefined) {
             const guide = compositeTaskGuides.find((candidate) => formatPathForPrompt(candidate.filePath) === path || candidate.filePath === path);
             if (guide) {
@@ -103,10 +155,10 @@ export function registerFilesystemTools(options) {
         const executionWorkspaceId = target.executionWorkspaceId;
         const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.read(executionWorkspaceId, { path, paths, offset, limit }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            return presentSemanticWorkResult(await remoteWorkspaces.read(executionWorkspaceId, { path, paths, offset, limit }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
         if (path !== undefined) {
-            return presentSemanticWorkResult(await coreOperations.read({ workspaceId: executionWorkspaceId, path, offset, limit }, executionContext), target);
+            return presentSemanticWorkResult(await coreOperations.read({ workspaceId: executionWorkspaceId, path, offset, limit }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
         const workspace = workspaces.getWorkspace(executionWorkspaceId);
         let response;
@@ -159,7 +211,7 @@ export function registerFilesystemTools(options) {
             : { type: "succeeded" }, activityRelationFor(executionContext));
         if (!response)
             throw new Error("Bulk Read completed without a response.");
-        return presentSemanticWorkResult(response, target);
+        return presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId));
     });
     if (config.toolMode !== "codex") {
         registerAppTool(server, toolNames.write, {
@@ -183,9 +235,9 @@ export function registerFilesystemTools(options) {
             const executionWorkspaceId = target.executionWorkspaceId;
             const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.write(executionWorkspaceId, input, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+                return presentSemanticWorkResult(await remoteWorkspaces.write(executionWorkspaceId, input, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
             }
-            return presentSemanticWorkResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target);
+            return presentSemanticWorkResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
         });
         registerAppTool(server, toolNames.edit, {
             title: "Edit file",
@@ -236,12 +288,12 @@ export function registerFilesystemTools(options) {
             const executionWorkspaceId = target.executionWorkspaceId;
             const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.edit(executionWorkspaceId, { path, paths, edits }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+                return presentSemanticWorkResult(await remoteWorkspaces.edit(executionWorkspaceId, { path, paths, edits }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
             }
             if (path !== undefined) {
-                return presentSemanticWorkResult(await coreOperations.edit({ workspaceId: executionWorkspaceId, path, edits }, executionContext), target);
+                return presentSemanticWorkResult(await coreOperations.edit({ workspaceId: executionWorkspaceId, path, edits }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
             }
-            return presentSemanticWorkResult(await nativeBulkMutations.edit({ workspaceId: executionWorkspaceId, paths: paths, edits }, executionContext), target);
+            return presentSemanticWorkResult(await nativeBulkMutations.edit({ workspaceId: executionWorkspaceId, paths: paths, edits }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
         });
     }
     registerAppTool(server, toolNames.rename, {
@@ -265,9 +317,9 @@ export function registerFilesystemTools(options) {
         const executionWorkspaceId = target.executionWorkspaceId;
         const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.rename(executionWorkspaceId, { path, newPath }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            return presentSemanticWorkResult(await remoteWorkspaces.rename(executionWorkspaceId, { path, newPath }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
-        return presentSemanticWorkResult(await coreOperations.rename({ workspaceId: executionWorkspaceId, path, newPath }, executionContext), target);
+        return presentSemanticWorkResult(await coreOperations.rename({ workspaceId: executionWorkspaceId, path, newPath }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
     });
     registerAppTool(server, toolNames.delete, {
         title: "Delete path",
@@ -308,12 +360,12 @@ export function registerFilesystemTools(options) {
         const executionWorkspaceId = target.executionWorkspaceId;
         const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.delete(executionWorkspaceId, { path, paths, recursive }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            return presentSemanticWorkResult(await remoteWorkspaces.delete(executionWorkspaceId, { path, paths, recursive }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
         if (path !== undefined) {
-            return presentSemanticWorkResult(await coreOperations.delete({ workspaceId: executionWorkspaceId, path, recursive }, executionContext), target);
+            return presentSemanticWorkResult(await coreOperations.delete({ workspaceId: executionWorkspaceId, path, recursive }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
-        return presentSemanticWorkResult(await nativeBulkMutations.delete({ workspaceId: executionWorkspaceId, paths: paths, recursive }, executionContext), target);
+        return presentSemanticWorkResult(await nativeBulkMutations.delete({ workspaceId: executionWorkspaceId, paths: paths, recursive }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
     });
     if (config.toolMode === "codex") {
         registerAppTool(server, "apply_patch", {
@@ -344,7 +396,7 @@ export function registerFilesystemTools(options) {
             const executionWorkspaceId = target.executionWorkspaceId;
             const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.applyPatch(executionWorkspaceId, { patch }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+                return presentSemanticWorkResult(await remoteWorkspaces.applyPatch(executionWorkspaceId, { patch }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
             }
             const workspace = workspaces.getWorkspace(executionWorkspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, patch }, executionContext), {
@@ -363,6 +415,9 @@ export function registerFilesystemTools(options) {
                     const displayPath = applied.files.length === 1
                         ? applied.files[0]?.path
                         : `${applied.files.length} files`;
+                    const diagnosticPaths = applied.files
+                        .filter((file) => file.operation !== "delete")
+                        .map((file) => file.path);
                     logToolCall(config, {
                         tool: "apply_patch",
                         ...workspaceLogContext(workspace, extra.sessionId),
@@ -370,7 +425,7 @@ export function registerFilesystemTools(options) {
                         success: true,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    return {
+                    return appendAutomaticMutationDiagnostics({
                         content,
                         _meta: {
                             tool: "apply_patch",
@@ -392,9 +447,9 @@ export function registerFilesystemTools(options) {
                             removals: applied.removals,
                             files: applied.files,
                         },
-                    };
+                    }, codeIntelligence, workspace.root, diagnosticPaths, extra.signal);
                 },
-            }, activityRelationFor(executionContext)).then((result) => presentSemanticWorkResult(result, target));
+            }, activityRelationFor(executionContext)).then((result) => presentSemanticWorkResult(result, target, hostScopeIdFor(extra._meta, extra.sessionId)));
         });
     }
 }

package/dist/mcp/server/operations/runtime/mutation-diagnostics.js

@@ -0,0 +1,54 @@
+import { CodeIntelligenceError } from "../../../../lsp/code-intelligence-error.js";
+import { textBlock } from "../../core/tool-support.js";
+const AUTO_DIAGNOSTIC_LIMIT = 20;
+export async function appendAutomaticMutationDiagnostics(result, codeIntelligence, workspaceRoot, paths, signal) {
+    const summary = await automaticMutationDiagnostics(codeIntelligence, workspaceRoot, paths, signal);
+    if (!summary)
+        return result;
+    return {
+        ...result,
+        content: [...result.content, textBlock(summary)],
+        structuredContent: {
+            ...result.structuredContent,
+            result: `${result.structuredContent.result}\n\n${summary}`,
+        },
+    };
+}
+export async function automaticMutationDiagnostics(codeIntelligence, workspaceRoot, paths, signal) {
+    const sections = [];
+    for (const path of Array.from(new Set(paths))) {
+        try {
+            const result = await codeIntelligence.run(workspaceRoot, { operation: "diagnostics", path, limit: AUTO_DIAGNOSTIC_LIMIT }, { signal });
+            if (result.operation !== "diagnostics" || result.diagnostics.length === 0)
+                continue;
+            sections.push(formatDiagnostics(result));
+        }
+        catch (error) {
+            if (error instanceof CodeIntelligenceError) {
+                if (error.code === "code.language_service_unavailable" || error.code === "code.operation_unsupported")
+                    continue;
+                sections.push(`Automatic diagnostics warning for ${path}: ${error.message}`);
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            sections.push(`Automatic diagnostics warning for ${path}: ${message}`);
+        }
+    }
+    if (sections.length === 0)
+        return undefined;
+    return [
+        "Automatic Language Server validation after this file change:",
+        ...sections,
+    ].join("\n");
+}
+function formatDiagnostics(result) {
+    const lines = result.diagnostics.map((diagnostic) => {
+        const location = `${result.path}:${diagnostic.range.start.line}:${diagnostic.range.start.column}`;
+        const severity = diagnostic.severity ? `[${diagnostic.severity}] ` : "";
+        const code = diagnostic.code === undefined ? "" : ` (${diagnostic.code})`;
+        return `- ${location} ${severity}${diagnostic.message}${code}`;
+    });
+    if (result.truncated)
+        lines.push(`- … more diagnostics were truncated (showing ${result.returned}${result.total === undefined ? "" : ` of ${result.total}`}).`);
+    return [`${result.selectedServer} · ${result.path}`, ...lines].join("\n");
+}

package/dist/mcp/server/operations/runtime/operation-runtime.js

@@ -12,8 +12,9 @@ import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from ".
 import { activityRelationFor, activityRequestFor, runActivityTool, runActivityToolWithHooks, standardActivityOutcome, } from "../../core/activity-support.js";
 import { capabilityContextFor, workspaceHookInvocation } from "../../core/capability-support.js";
 import { assertWorkspaceInstructionsLoadedBeforeSideEffect, contentLineCount, contentText, countDiffStats, formatDiscoveredWorkspaceInstructions, logFailedToolResponse, logToolCall, newFilePatch, textBlock, textSummary, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
+import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 export function createOperationRuntime(options) {
-    const { config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore, capabilityRegistry, hostScopeIdFor } = options;
+    const { config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore, capabilityRegistry, codeIntelligence, hostScopeIdFor, } = options;
     const coreOperations = createCoreOperationExecutor({
         read: async (input, context) => {
             const { workspaceId, ...readInput } = input;
@@ -127,7 +128,7 @@ export function createOperationRuntime(options) {
                         success: true,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    return {
+                    return appendAutomaticMutationDiagnostics({
                         ...response,
                         _meta: {
                             tool: toolNames.write,
@@ -144,7 +145,7 @@ export function createOperationRuntime(options) {
                         structuredContent: {
                             result: contentText(response.content),
                         },
-                    };
+                    }, codeIntelligence, workspace.root, [writeInput.path], context.signal);
                 },
             }, activityRelationFor(context));
         },
@@ -188,7 +189,7 @@ export function createOperationRuntime(options) {
                         success: true,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    return {
+                    return appendAutomaticMutationDiagnostics({
                         content: editContent,
                         _meta: {
                             tool: toolNames.edit,
@@ -206,7 +207,7 @@ export function createOperationRuntime(options) {
                             status: "applied",
                             result: contentText(editContent),
                         },
-                    };
+                    }, codeIntelligence, workspace.root, [editInput.path], context.signal);
                 },
             }, activityRelationFor(context));
         },
@@ -236,7 +237,7 @@ export function createOperationRuntime(options) {
                             success: true,
                             durationMs: Math.round(performance.now() - startedAt),
                         });
-                        return {
+                        return appendAutomaticMutationDiagnostics({
                             content,
                             _meta: {
                                 tool: toolNames.rename,
@@ -253,7 +254,7 @@ export function createOperationRuntime(options) {
                                 path,
                                 newPath,
                             },
-                        };
+                        }, codeIntelligence, workspace.root, [newPath], context.signal);
                     }
                     catch (error) {
                         logToolCall(config, {

package/dist/mcp/server/workspace/runtime/workspace-open-presentation.js

@@ -9,15 +9,27 @@ import { formatUnavailableSubagentProvider } from "../../../../subagents/provide
 import { capabilityContextFor } from "../../core/capability-support.js";
 import { redactSkillDiagnosticPaths } from "../../core/schemas.js";
 import { logToolCall, workspaceLogContext } from "../../core/tool-support.js";
+export const workspaceTaskUsageInstruction = "Use workspace.tasks proactively for work that spans multiple steps or sessions: create or update Tasks to preserve useful next steps and current state, and read its summary when resuming relevant unfinished work. Do not query it mechanically on every open_workspace call.";
 export async function presentLocalWorkspaceOpen(options, input, contextData) {
     const { config, forgerelayVersion: FORGERELAY_VERSION, workspaces, workspaceTasks, reviewCheckpoints, capabilityRegistry, subagentProviders, hooks, rememberWorkspacePanelState, } = options;
     const { path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context } = input;
     const { conversationScopeId, protectedWorkspaceIds, startedAt, sessionId } = contextData;
-    const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, bootstrapContextComponents, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
+    const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, bootstrapContextComponents, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
         conversationScopeId,
         protectedWorkspaceIds,
     });
     workspaceTasks.initializeWorkspace(workspace.id);
+    const requestedContext = context ?? "auto";
+    const resourceUpdate = workspaceReused && requestedContext === "auto"
+        ? workspaces.claimResourceUpdates(workspace.id, conversationScopeId)
+        : undefined;
+    if (requestedContext === "full" || (!workspaceReused && requestedContext !== "none")) {
+        workspaces.acknowledgeResourceUpdates(workspace.id, conversationScopeId);
+    }
+    const effectiveBootstrapContextComponents = resourceUpdate
+        ? bootstrapContextComponents.filter((component) => !resourceUpdate.coveredComponents.includes(component))
+        : bootstrapContextComponents;
+    const effectiveIncludeBootstrapContext = effectiveBootstrapContextComponents.length > 0 || Boolean(resourceUpdate);
     const knownWorktrees = await workspaces.listKnownWorktrees(workspace);
     const staleWorkspaces = await workspaces.listStaleWorkspaces(workspace);
     const capabilityFingerprint = buildCapabilityFingerprint(config, FORGERELAY_VERSION, {
@@ -59,7 +71,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
     const cardAvailableAgentsFiles = availableAgentsFiles.map((file) => ({
         path: formatAgentsPath(file.path, workspace.root),
     }));
-    const bootstrapComponents = new Set(bootstrapContextComponents);
+    const bootstrapComponents = new Set(effectiveBootstrapContextComponents);
     const visibleSkills = bootstrapComponents.has("skills") ? cardSkills : [];
     const visibleSkillDiagnostics = bootstrapComponents.has("skillDiagnostics")
         ? redactSkillDiagnosticPaths(workspace.skillDiagnostics)
@@ -72,16 +84,23 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
         ? 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 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.",
+        capabilityCatalog.some((entry) => entry.name === "workspace.tasks")
+            ? workspaceTaskUsageInstruction
+            : undefined,
+    ].filter(Boolean).join(" ");
     const cardInstruction = config.skillsEnabled
         ? `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill, load it with read(path=\"skills://<name>\") before proceeding. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`
         : `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`;
     const instruction = workspaceReused
-        ? includeBootstrapContext
+        ? effectiveIncludeBootstrapContext
             ? [
                 `Workspace already exists as ${workspace.id} for this directory.`,
                 "Reuse this workspaceId for subsequent tool calls.",
-                `Project bootstrap context components included in this response: ${bootstrapContextComponents.join(", ")}. Components not listed are unchanged and are not repeated.`,
+                effectiveBootstrapContextComponents.length > 0
+                    ? `Project bootstrap context components included in this response: ${effectiveBootstrapContextComponents.join(", ")}. Components not listed are unchanged and are not repeated.`
+                    : "Only Workspace context deltas are included in this response; unchanged bootstrap context is not repeated.",
                 workspaceContextInstruction,
                 workspaceManagementInstruction,
             ].join("\n\n")
@@ -93,7 +112,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
                 workspaceManagementInstruction,
             ].join("\n\n")
         : workspace.mode === "worktree"
-            ? "Use this workspaceId for subsequent tool calls. Follow the project instructions, nested instruction files, skills, agent profiles, and diagnostics returned for this isolated worktree."
+            ? `Use this workspaceId for subsequent tool calls. Follow the project instructions, nested instruction files, skills, agent profiles, and diagnostics returned for this isolated worktree. ${workspaceManagementInstruction}`
             : cardInstruction;
     const resultContent = [
         {
@@ -138,6 +157,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
                     : undefined,
                 `ForgeRelay ${capabilityFingerprint.version} capabilities: ${capabilityFingerprint.capabilities.join(", ")}`,
                 instruction,
+                resourceUpdate?.text,
             ].filter(Boolean).join("\n"),
         },
     ];
@@ -155,7 +175,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
         path: workspace.root,
         mode: workspace.mode,
         workspaceReused,
-        includeBootstrapContext,
+        includeBootstrapContext: effectiveIncludeBootstrapContext,
         sourceRoot: workspace.sourceRoot,
         worktree: workspace.worktree,
         worktrees: knownWorktrees,
@@ -183,7 +203,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
         content: resultContent,
         _meta: {
             tool: "open_workspace",
-            card: includeBootstrapContext
+            card: effectiveIncludeBootstrapContext
                 ? workspaceCard
                 : compactWorkspacePresentation(workspaceCard),
         },

package/dist/mcp/server/workspace/runtime/workspace-open.js

@@ -4,7 +4,7 @@ import { formatPathForPrompt } from "../../../../workspaces/resources/skills.js"
 import { compositeCapabilityContext } from "../../core/capability-support.js";
 import { logToolCall, textBlock } from "../../core/tool-support.js";
 import { openWorkspaceToolDefinition } from "./workspace-open-schema.js";
-import { presentLocalWorkspaceOpen } from "./workspace-open-presentation.js";
+import { presentLocalWorkspaceOpen, workspaceTaskUsageInstruction, } from "./workspace-open-presentation.js";
 export function registerOpenWorkspaceTool(options) {
     const { server } = options;
     registerAppTool(server, "open_workspace", openWorkspaceToolDefinition, (args, extra) => handleOpenWorkspace(options, args, extra));
@@ -405,6 +405,9 @@ async function handleOpenWorkspace(options, input, extra) {
             compositeCapabilityCatalog.length > 0
                 ? `Composite-owned capabilities: ${compositeCapabilityCatalog.map((entry) => entry.name).join(", ")}. Use these without member because their state belongs to the Composite Workspace itself.`
                 : undefined,
+            compositeCapabilityCatalog.some((entry) => entry.name === "workspace.tasks")
+                ? workspaceTaskUsageInstruction
+                : undefined,
             composite.members.length > 0
                 ? "Before first work on a member, reopen this Composite Workspace with memberName=<member> and context=auto to receive that member's project bootstrap without creating an implicit current member."
                 : undefined,

package/dist/mcp/server/workspace/runtime/workspace-tools.js

@@ -170,7 +170,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 ...(file !== undefined ? { file } : {}),
             }, hostScopeIdFor(extra._meta, extra.sessionId));
             return action === "run" && name !== "workspace.tasks"
-                ? presentSemanticWorkResult(response, target)
+                ? presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId))
                 : presentExecutionResult(response, target);
         }
         if (action === "run" && name === "batch.execute") {
@@ -195,7 +195,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     success: true,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return presentSemanticWorkResult(result, target);
+                return presentSemanticWorkResult(result, target, hostScopeIdFor(extra._meta, extra.sessionId));
             }
             catch (error) {
                 if (extra.signal.aborted)
@@ -225,7 +225,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             const response = await coreOperations.capabilityRun({ workspaceId: executionWorkspaceId, name, arguments: capabilityArguments, file }, executionContext);
             return name === "workspace.tasks"
                 ? presentExecutionResult(response, target)
-                : presentSemanticWorkResult(response, target);
+                : presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId));
         }
         const workspace = workspaces.getWorkspace(executionWorkspaceId);
         return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {

package/dist/mcp/server-instructions.js

@@ -24,7 +24,7 @@ export function buildToolDescriptions(config) {
         ? ""
         : " Use shell commands for search and directory inspection instead of dedicated MCP search tools.";
     return {
-        read: `Read one file or multiple files inside an open workspace or the OS temp directory. Use path for one target or paths for multiple targets; offset/limit apply to every target in a bulk read. Instruction files and advertised capability guides returned by ${toolNames.openWorkspace} are also readable when applicable.${skillCapability} Only advertised entry files and files under already-loaded advertised directories are readable outside the normal roots. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        read: `Read one file or multiple files. Inside an open workspace, relative paths, Workspace instructions, advertised capability guides, and loaded advertised resources are available as usual.${skillCapability} For read-only inspection before opening a Workspace, omit workspaceId and use absolute paths already inside configured allowedRoots; unscoped reads never activate Workspace instructions, Skills, capabilities, or execution state. Use path for one target or paths for multiple targets; offset/limit apply to every target in a bulk read.`,
         write: `Create or completely overwrite a file inside an open workspace or the OS temp directory. Workspace paths may be relative; OS temp paths may be absolute. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         edit: `Edit one file or multiple files inside an open workspace or the OS temp directory by replacing exact text blocks. Use path for one target or paths for multiple targets; a bulk Edit applies the same edits to every file and preflights all targets before the first mutation. Each oldText must match a unique, non-overlapping region of the original file. Workspace paths may be relative; OS temp paths may be absolute. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         rename: `Rename or move one file or directory inside an open workspace or the OS temp directory without overwriting an existing destination. Source and destination must both remain inside the permitted file roots. Call ${toolNames.openWorkspace} first and pass workspaceId.`,

package/dist/runtime/config/config.js

@@ -261,6 +261,7 @@ export function loadConfig(env = process.env) {
             ? files.config.subagents === true
             : parseBoolean(productEnv(env, "SUBAGENTS")),
         languageServers: files.config.languageServers ?? {},
+        allowAgentLanguageServerInstall: files.config.allowAgentLanguageServerInstall === true,
         agentDir: resolve(expandHomePath(productEnv(env, "AGENT_DIR") ?? files.config.agentDir ?? defaultAgentDir())),
         systemInstructionsPath: parseSystemInstructionsPath(productEnv(env, "SYSTEM_INSTRUCTIONS_PATH") ?? files.config.systemInstructionsPath),
         hooks: mergeHookConfigs(parseHookConfig(files.config.hooks), parseHookConfig(files.hooks), files.hookFiles),

package/dist/runtime/config/user-config.js

@@ -1,7 +1,7 @@
 import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { withFileLock } from "../state/lock/file-lock.js";
 import { expandHomePath } from "../../mcp/filesystem/roots.js";
 import { mergeHookConfigs, parseHookFile, } from "../../mcp/hooks/hooks.js";
@@ -135,15 +135,6 @@ export async function removeForgeRelayRemote(alias, env = process.env) {
         return { ...auth, remotes };
     }, env);
 }
-export function ensureForgeRelayDefaultSkills(env = process.env) {
-    const targetPath = join(forgerelaySkillsDir(env), "subagent-delegation", "SKILL.md");
-    if (existsSync(targetPath))
-        return [];
-    const sourcePath = new URL("../../../skills/subagent-delegation/SKILL.md", import.meta.url);
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, readFileSync(sourcePath, "utf8"), { mode: 0o644 });
-    return [targetPath];
-}
 export function resolveSubagentsFlag(config, env = process.env) {
     const value = env.FORGERELAY_SUBAGENTS;
     if (value === undefined)

package/dist/server.js

@@ -10,6 +10,7 @@ import { downloadIncomingArtifact, isArtifactDownloadSupportedPlatform } from ".
 import { ArtifactError } from "./mcp/artifacts/artifact-error.js";
 import { loadConfig } from "./runtime/config/config.js";
 import { CodeIntelligenceError } from "./lsp/code-intelligence.js";
+import { installManagedLanguageServers, installedManagedLanguageServers, supportedManagedLanguageServers, } from "./lsp/runtime/managed-language-servers.js";
 import { HookRunner } from "./mcp/hooks/hooks.js";
 import { checkHookConfiguration } from "./mcp/hooks/hook-cli.js";
 import { buildServerInstructions, buildToolDescriptions, toolNames } from "./mcp/server-instructions.js";
@@ -38,7 +39,7 @@ import { createOperationRuntime } from "./mcp/server/operations/runtime/operatio
 import { registerWorkspaceAuxiliaryTools } from "./mcp/server/workspace/runtime/workspace-tools.js";
 import { registerOpenWorkspaceTool } from "./mcp/server/workspace/runtime/workspace-open.js";
 import { redactSkillDiagnosticPaths } from "./mcp/server/core/schemas.js";
-import { attachWorkspaceTaskReminder, remapCompositeToolResult, toolResultIsError } from "./mcp/server/core/tool-support.js";
+import { attachWorkspaceContextUpdate, attachWorkspaceTaskReminder, remapCompositeToolResult, toolResultIsError } from "./mcp/server/core/tool-support.js";
 export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, options = {}) {
     const connectionScopeId = `mcp-connection:${randomUUID()}`;
     const activityPanelApp = createActivityPanelApp(config, FORGERELAY_VERSION);
@@ -95,10 +96,14 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             return undefined;
         }
     };
-    const presentSemanticWorkResult = (result, target) => {
-        const presented = presentExecutionResult(result, target);
+    const presentSemanticWorkResult = (result, target, conversationScopeId) => {
+        let presented = presentExecutionResult(result, target);
         if (toolResultIsError(presented))
             return presented;
+        if (!remoteWorkspaces.has(target.executionWorkspaceId)) {
+            const update = workspaces.claimResourceUpdates(target.executionWorkspaceId, conversationScopeId);
+            presented = attachWorkspaceContextUpdate(presented, update?.text);
+        }
         const reminderWorkspaceId = taskReminderWorkspaceIdFor(target);
         return attachWorkspaceTaskReminder(presented, reminderWorkspaceId ? taskReminders.recordWork(reminderWorkspaceId) : undefined);
     };
@@ -154,10 +159,33 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         },
         codeIntelligence: {
             available: true,
-            run: async (input, context, options) => {
+            run: async (input, context, runOptions) => {
+                if (input.operation === "managed.status") {
+                    return {
+                        value: {
+                            supported: supportedManagedLanguageServers(),
+                            installed: installedManagedLanguageServers(config.configDir),
+                            agentInstallAllowed: config.allowAgentLanguageServerInstall,
+                        },
+                    };
+                }
+                if (input.operation === "managed.install") {
+                    if (!config.allowAgentLanguageServerInstall) {
+                        throw new CapabilityError("code.managed_install_disabled", "Agent-managed Language Server installation is disabled. Enable it explicitly with forgerelay init --force.");
+                    }
+                    const install = options.managedLanguageServerInstaller ?? installManagedLanguageServers;
+                    const installed = await install(input.servers, config.configDir);
+                    return {
+                        value: {
+                            ...installed,
+                            availableNow: installedManagedLanguageServers(config.configDir),
+                            restartRequired: false,
+                        },
+                    };
+                }
                 try {
                     return {
-                        value: await codeIntelligence.run(requireCapabilityWorkspaceRoot(context), input, { signal: options.signal }),
+                        value: await codeIntelligence.run(requireCapabilityWorkspaceRoot(context), input, { signal: runOptions.signal }),
                     };
                 }
                 catch (error) {
@@ -291,7 +319,8 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         };
     };
     const operationRuntime = createOperationRuntime({
-        config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore, capabilityRegistry, hostScopeIdFor,
+        config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore,
+        capabilityRegistry, codeIntelligence, hostScopeIdFor,
     });
     batchExecutor = operationRuntime.batchExecutor;
     const { coreOperations, nativeBulkMutations } = operationRuntime;
@@ -430,6 +459,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         coreOperations,
         nativeBulkMutations,
         activityLifecycle,
+        codeIntelligence,
         hooks,
         toolDescriptions,
         resolveExecutionTarget,