@akira-tl/forgerelay 0.8.6 → 0.8.7

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.8.7] - 2026-09-02
+
+### Changed
+
+- `open_workspace(context="auto")` now tracks bootstrap delivery per component and returns only changed or removed AGENTS/nested-instruction, Skill/diagnostic, Capability-guide, and Subagent-profile domains after the first full delivery; `full`, `none`, Composite member, Relay, and legacy whole-fingerprint delivery behavior remain compatible.
+- Bash guidance now requires long `yieldTimeMs` waits for long-running or wait-only process operations, explicitly noting that completion returns immediately before the feedback window expires so Agents do not short-poll every few seconds.
+
 ## [0.8.6] - 2026-09-02
 
 ### Added

package/dist/db/migrations.js

@@ -79,6 +79,11 @@ const migrations = [
         name: "workspace-session-aliases",
         up: migrateWorkspaceSessionAliases,
     },
+    {
+        version: 17,
+        name: "workspace-context-components",
+        up: migrateWorkspaceContextComponents,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -387,6 +392,10 @@ function migrateWorkspaceSessionAliases(sqlite) {
       on workspace_session_aliases(workspace_session_id);
   `);
 }
+function migrateWorkspaceContextComponents(sqlite) {
+    migrateWorkspaceContextDeliveries(sqlite);
+    addColumnIfMissing(sqlite, "workspace_context_deliveries", "component_fingerprints_json", "text");
+}
 function migrateActivityHostTurnWorkspace(sqlite) {
     migrateActivityHostTurns(sqlite);
     addColumnIfMissing(sqlite, "activity_host_turns", "workspace_id", "text");

package/dist/db/schema.js

@@ -53,6 +53,7 @@ export const workspaceContextDeliveries = sqliteTable("workspace_context_deliver
     conversationScopeId: text("conversation_scope_id").notNull(),
     targetKey: text("target_key").notNull(),
     contextFingerprint: text("context_fingerprint").notNull(),
+    componentFingerprintsJson: text("component_fingerprints_json"),
     deliveredAt: text("delivered_at").notNull(),
 }, (table) => [
     primaryKey({ columns: [table.conversationScopeId, table.targetKey] }),

package/dist/mcp/server-instructions.js

@@ -30,7 +30,7 @@ export function buildToolDescriptions(config) {
         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.`,
         delete: `Delete one path or multiple paths inside an open workspace or the OS temp directory. Use path for one target or paths for multiple targets; a bulk Delete preflights all targets before deleting anything. Non-empty directories require recursive=true. An allowed root itself cannot be deleted. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         applyPatch: `Apply one Codex-style patch inside an open workspace or the OS temp directory. Supports adding, overwriting, updating, deleting, and moving files. Workspace paths must remain relative; absolute paths are accepted only inside the OS temp directory. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
-        shell: `Run or manage a shell process inside an open workspace.${shellSurface} Commands execute with the local user's authority; workspace containment does not make shell execution a sandbox. For action=run, yieldTimeMs is only the feedback wait (default 10000ms; 0 returns a processId immediately) and optional timeoutMs is the independent total execution limit. action=process polls/waits for incremental output, writes input, resizes a PTY, or interrupts by processId. Keep explicit waits below the Host request deadline; use 60000ms only when supported. Completed background results may be attached to a later result for the same workspaceId. Call ${toolNames.openWorkspace} first and pass workspaceId. Expose this capability only behind strong authentication.`,
+        shell: `Run or manage a shell process inside an open workspace.${shellSurface} Commands run with the local user's authority; workspace containment does not make shell execution a sandbox. For action=run, yieldTimeMs is the feedback wait (default 10000ms; 0 returns processId) and timeoutMs is the independent execution limit. action=process waits/interacts with processId. For long-running commands or wait-only process calls, set a long yieldTimeMs near the Host deadline (60000ms when supported), not short polling. This wait is a maximum: if the process finishes sooner, the call returns immediately. If still running, reuse processId with another long wait; use short waits only for interaction. Background completions can arrive later. Call ${toolNames.openWorkspace} first with workspaceId. Expose only behind strong authentication.`,
         shellCommand: "Shell command to run with the local user's authority.",
     };
 }
@@ -61,7 +61,7 @@ function defaultWorkflowInstructions(config) {
         return `Use ${toolNames.read} for direct file reads, ${toolNames.rename} and ${toolNames.delete} for direct path moves or removals, apply_patch for content modifications, exec_command for inspection, tests, builds, and other commands, and ${toolNames.writeStdin} to poll or interact with running processes.`;
     }
     const inspection = `Use ${toolNames.shell} with command-line tools such as grep, rg, find, ls, and tree for search and directory inspection.`;
-    return joinInstructions(inspection, `Prefer ${toolNames.edit} for targeted content modifications, ${toolNames.write} only for new files or complete rewrites, ${toolNames.rename} for path moves, ${toolNames.delete} for removals, and ${toolNames.shell} for tests, builds, Git/package scripts, generators, formatters, and shell-suited commands. If ${toolNames.shell} returns a running processId, use action=\"process\" to poll/wait/interact/resize/interrupt it. When only waiting, set yieldTimeMs instead of short polling; reuse processId if still running. Otherwise keep working and consume its later completion notice.`);
+    return joinInstructions(inspection, `Prefer ${toolNames.edit} for targeted content modifications, ${toolNames.write} only for new files or complete rewrites, ${toolNames.rename} for path moves, ${toolNames.delete} for removals, and ${toolNames.shell} for tests, builds, Git/package scripts, generators, formatters, and shell-suited commands. For long ${toolNames.shell} commands or wait-only calls, set yieldTimeMs near Host deadline (60000ms when supported); do not poll every few seconds. Completion returns immediately if sooner; if still running, reuse processId with a long wait. Short waits are only for interaction.`);
 }
 function joinInstructions(...parts) {
     return parts

package/dist/server.js

@@ -56,7 +56,7 @@ import { createWorkspaceStore } from "./workspace-store.js";
 import { WorkspaceTaskReminderTracker } from "./workspace-task-reminders.js";
 import { WorkspaceTaskStore } from "./workspace-tasks.js";
 import { compactWorkspacePresentation } from "./workspace-presentation.js";
-import { formatAgentsPath, WorkspaceRegistry } from "./workspaces.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";
@@ -1566,6 +1566,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 providerUnavailableReason: availability?.reason,
             };
         });
+        const bootstrapComponents = new Set(opened.bootstrapContextComponents);
         return {
             member: memberName,
             workspaceId: compositeWorkspaceId,
@@ -1575,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.`
@@ -2888,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,
         });
@@ -2934,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
@@ -2953,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")
@@ -3072,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,
             },
@@ -4097,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()

package/dist/workspace-store.js

@@ -266,9 +266,18 @@ export class SqliteWorkspaceStore {
     }
     setContextDelivery(input) {
         const deliveredAt = new Date().toISOString();
+        const componentFingerprintsJson = input.componentFingerprints
+            ? JSON.stringify(input.componentFingerprints)
+            : null;
         const row = this.database.db
             .insert(workspaceContextDeliveries)
-            .values({ ...input, deliveredAt })
+            .values({
+            conversationScopeId: input.conversationScopeId,
+            targetKey: input.targetKey,
+            contextFingerprint: input.contextFingerprint,
+            componentFingerprintsJson,
+            deliveredAt,
+        })
             .onConflictDoUpdate({
             target: [
                 workspaceContextDeliveries.conversationScopeId,
@@ -276,6 +285,7 @@ export class SqliteWorkspaceStore {
             ],
             set: {
                 contextFingerprint: input.contextFingerprint,
+                componentFingerprintsJson,
                 deliveredAt,
             },
         })
@@ -388,10 +398,28 @@ function rowToWorkspaceConversationBinding(row) {
     };
 }
 function rowToWorkspaceContextDelivery(row) {
+    const componentFingerprints = parseContextComponentFingerprints(row.componentFingerprintsJson);
     return {
         conversationScopeId: row.conversationScopeId,
         targetKey: row.targetKey,
         contextFingerprint: row.contextFingerprint,
+        ...(componentFingerprints ? { componentFingerprints } : {}),
         deliveredAt: row.deliveredAt,
     };
 }
+function parseContextComponentFingerprints(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const entries = Object.entries(parsed);
+        if (entries.some(([, fingerprint]) => typeof fingerprint !== "string"))
+            return undefined;
+        return Object.fromEntries(entries);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/workspaces.js

@@ -190,30 +190,35 @@ export class WorkspaceRegistry {
             : await this.reusedWorkspaceContext(await this.workspaceForOpen(workspaceId));
         const workspace = context.workspace;
         if (!conversationScopeId || !this.store) {
+            const bootstrapContextComponents = resolveBootstrapContextComponents(bootstrapContext, context.bootstrapComponentFingerprints, []);
             return {
                 ...context,
-                includeBootstrapContext: bootstrapContext !== "none",
+                bootstrapContextComponents,
+                includeBootstrapContext: bootstrapContextComponents.length > 0,
             };
         }
         const targetKeys = await this.workspaceTargetKeys(workspace);
-        const contextAlreadyDelivered = targetKeys.some((targetKey) => this.store?.getContextDelivery(conversationScopeId, targetKey)?.contextFingerprint ===
-            context.contextFingerprint);
-        const includeBootstrapContext = resolveBootstrapContextVisibility(bootstrapContext, contextAlreadyDelivered);
+        const deliveries = targetKeys
+            .map((targetKey) => this.store?.getContextDelivery(conversationScopeId, targetKey))
+            .filter((delivery) => delivery !== undefined);
+        const bootstrapContextComponents = resolveBootstrapContextComponents(bootstrapContext, context.bootstrapComponentFingerprints, deliveries, context.contextFingerprint);
+        const includeBootstrapContext = bootstrapContextComponents.length > 0;
         for (const targetKey of targetKeys) {
             this.store.setConversationBinding({
                 conversationScopeId,
                 targetKey,
                 workspaceSessionId: workspace.id,
             });
-            if (includeBootstrapContext) {
+            if (bootstrapContext !== "none" && (includeBootstrapContext || deliveries.some((delivery) => delivery.contextFingerprint === context.contextFingerprint && !delivery.componentFingerprints))) {
                 this.store.setContextDelivery({
                     conversationScopeId,
                     targetKey,
                     contextFingerprint: context.contextFingerprint,
+                    componentFingerprints: context.bootstrapComponentFingerprints,
                 });
             }
         }
-        return { ...context, includeBootstrapContext };
+        return { ...context, bootstrapContextComponents, includeBootstrapContext };
     }
     async listStaleWorkspaces(workspace) {
         if (!this.store)
@@ -483,26 +488,32 @@ export class WorkspaceRegistry {
     }
     withConversationContext(context, conversationScopeId, targetKey, bootstrapContext) {
         if (!conversationScopeId || !this.store) {
+            const bootstrapContextComponents = resolveBootstrapContextComponents(bootstrapContext, context.bootstrapComponentFingerprints, []);
             return {
                 ...context,
-                includeBootstrapContext: bootstrapContext !== "none",
+                bootstrapContextComponents,
+                includeBootstrapContext: bootstrapContextComponents.length > 0,
             };
         }
         const delivery = this.store.getContextDelivery(conversationScopeId, targetKey);
-        const includeBootstrapContext = resolveBootstrapContextVisibility(bootstrapContext, delivery?.contextFingerprint === context.contextFingerprint);
+        const bootstrapContextComponents = resolveBootstrapContextComponents(bootstrapContext, context.bootstrapComponentFingerprints, delivery ? [delivery] : [], context.contextFingerprint);
+        const includeBootstrapContext = bootstrapContextComponents.length > 0;
         this.store.setConversationBinding({
             conversationScopeId,
             targetKey,
             workspaceSessionId: context.workspace.id,
         });
-        if (includeBootstrapContext) {
+        if (bootstrapContext !== "none" &&
+            (includeBootstrapContext ||
+                (delivery?.contextFingerprint === context.contextFingerprint && !delivery.componentFingerprints))) {
             this.store.setContextDelivery({
                 conversationScopeId,
                 targetKey,
                 contextFingerprint: context.contextFingerprint,
+                componentFingerprints: context.bootstrapComponentFingerprints,
             });
         }
-        return { ...context, includeBootstrapContext };
+        return { ...context, bootstrapContextComponents, includeBootstrapContext };
     }
     pruneIdleWorkspaceSessions(protectedWorkspaceIds, force = false) {
         if (!this.store)
@@ -691,12 +702,14 @@ export class WorkspaceRegistry {
         workspace.loadedInstructionRealPaths.clear();
         const agentsFiles = await this.loadInitialAgentsFiles(workspace);
         const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
-        const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
+        const { contextFingerprint, componentFingerprints: bootstrapComponentFingerprints, } = bootstrapContextFingerprints(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
             agentsFiles,
             availableAgentsFiles,
             contextFingerprint,
+            bootstrapComponentFingerprints,
+            bootstrapContextComponents: [...BOOTSTRAP_CONTEXT_COMPONENTS],
             hookReports: [],
             workspaceReused: true,
             includeBootstrapContext: true,
@@ -994,12 +1007,14 @@ export class WorkspaceRegistry {
         });
         const agentsFiles = await this.loadInitialAgentsFiles(workspace);
         const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
-        const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
+        const { contextFingerprint, componentFingerprints: bootstrapComponentFingerprints, } = bootstrapContextFingerprints(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
             agentsFiles,
             availableAgentsFiles,
             contextFingerprint,
+            bootstrapComponentFingerprints,
+            bootstrapContextComponents: [...BOOTSTRAP_CONTEXT_COMPONENTS],
             hookReports,
             workspaceReused: false,
             includeBootstrapContext: true,
@@ -1152,14 +1167,28 @@ export class WorkspaceRegistry {
         return loaded;
     }
 }
-function resolveBootstrapContextVisibility(mode, contextAlreadyDelivered) {
-    if (mode === "full")
-        return true;
+const BOOTSTRAP_CONTEXT_COMPONENTS = [
+    "agentsFiles",
+    "availableAgentsFiles",
+    "skills",
+    "skillDiagnostics",
+    "capabilityGuides",
+    "agentProfiles",
+];
+function resolveBootstrapContextComponents(mode, currentFingerprints, deliveries, contextFingerprint) {
     if (mode === "none")
-        return false;
-    return !contextAlreadyDelivered;
+        return [];
+    if (mode === "full")
+        return [...BOOTSTRAP_CONTEXT_COMPONENTS];
+    if (deliveries.length === 0)
+        return [...BOOTSTRAP_CONTEXT_COMPONENTS];
+    if (contextFingerprint &&
+        deliveries.some((delivery) => !delivery.componentFingerprints && delivery.contextFingerprint === contextFingerprint)) {
+        return [];
+    }
+    return BOOTSTRAP_CONTEXT_COMPONENTS.filter((component) => !deliveries.some((delivery) => delivery.componentFingerprints?.[component] === currentFingerprints[component]));
 }
-function bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles) {
+function bootstrapContextFingerprints(workspace, agentsFiles, availableAgentsFiles) {
     const payload = {
         agentsFiles: agentsFiles
             .map((file) => ({ path: resolve(file.path), content: file.content }))
@@ -1195,7 +1224,18 @@ function bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFile
         }))
             .sort((left, right) => left.name.localeCompare(right.name)),
     };
-    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+    const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+    return {
+        contextFingerprint: hash(payload),
+        componentFingerprints: {
+            agentsFiles: hash(payload.agentsFiles),
+            availableAgentsFiles: hash(payload.availableAgentsFiles),
+            skills: hash(payload.skills),
+            skillDiagnostics: hash(payload.skillDiagnostics),
+            capabilityGuides: hash(payload.capabilityGuides),
+            agentProfiles: hash(payload.agentProfiles),
+        },
+    };
 }
 function canonicalPersistedWorkspacePath(path) {
     const missingSegments = [];

package/docs/chatgpt-coding-workflow.md

@@ -30,12 +30,14 @@ open_workspace(path="~/project")
 ```
 
 The default `context="auto"` keeps the first useful bootstrap while avoiding
-replay. ForgeRelay tracks delivered context by conversation plus canonical
-Workspace target and a content fingerprint, independently from persistent
-Workspace identity. Different conversations may reuse the same `workspaceId` while
-each receives the current bootstrap once. If loaded instruction contents or
-relevant Skill, Capability guide, profile, diagnostic, or nested-instruction
-metadata changes, the next automatic open returns the refreshed bootstrap.
+replay. ForgeRelay tracks delivery by conversation plus canonical Workspace target,
+with both an overall `contextFingerprint` and component fingerprints for loaded
+instructions, nested-instruction discovery, Skills, Skill diagnostics, Capability
+guides, and Subagent profiles. Different conversations may reuse the same
+`workspaceId` while each receives the current bootstrap independently. After the
+first full delivery, an automatic open returns only components that changed or were
+removed; an emptied component is returned as an empty array so the Host can clear
+stale state without replaying unrelated bootstrap context.
 
 Two explicit controls are available for exceptional cases:
 
@@ -44,10 +46,10 @@ open_workspace(workspaceId="ws_...", context="full")
 open_workspace(workspaceId="ws_...", context="none")
 ```
 
-`full` forces a bootstrap refresh. `none` opens/resumes the Workspace without
-returning the full project context and does not record the current fingerprint as
-already delivered. Context-delivery state remains conversation-scoped and does not
-change the persistent Workspace identity.
+`full` forces every bootstrap component to refresh. `none` opens/resumes the
+Workspace without returning bootstrap components and does not acknowledge changed
+component fingerprints as delivered. Context-delivery state remains
+conversation-scoped and does not change the persistent Workspace identity.
 
 Do not enumerate Workspace state on every normal open. Use the same Core tool in
 inventory mode only when the user wants to discover known Workspaces, continue earlier

package/docs/configuration.md

@@ -287,16 +287,20 @@ deprecated compatibility input and no longer allocates another identity for the
 same physical target; use `newWorktree: true` for genuinely separate Git isolation.
 
 Bootstrap delivery is tracked separately from Workspace identity.
-`open_workspace` defaults to `context="auto"`: ForgeRelay fingerprints the current
-project context and returns the full AGENTS/Skills/Capability-guide/profile bootstrap
-only when that conversation has not already received the current fingerprint for
-the canonical workspace target. `context="full"` forces a refresh;
-`context="none"` opens or resumes the Workspace without returning the full bootstrap
-and does not mark the current fingerprint as delivered. Conversation-scoped
-bootstrap delivery therefore remains independent from the persistent Workspace
-identity: another conversation may reuse the same Workspace while independently
-receiving the current bootstrap once, and changed context produces a new fingerprint
-for the next `auto` open.
+`open_workspace` defaults to `context="auto"`: ForgeRelay keeps the overall
+`contextFingerprint` for change detection while also tracking fingerprints for the
+individual bootstrap components (`agentsFiles`, nested-instruction discovery,
+Skills, Skill diagnostics, Capability guides, and Subagent profiles). The first
+useful open returns the complete bootstrap; later `auto` opens return only components
+whose current fingerprint has not already been delivered to that conversation for
+the canonical Workspace target. A changed component is returned as its complete
+current value, including an empty array when previously delivered content was removed,
+so Hosts can clear stale bootstrap state without receiving unrelated context again.
+`context="full"` forces every component to be returned. `context="none"` opens or
+resumes the Workspace without returning bootstrap components and does not acknowledge
+new component fingerprints. Conversation-scoped bootstrap delivery therefore remains
+independent from the persistent Workspace identity, and another conversation may reuse
+the same Workspace while receiving its own current bootstrap state.
 
 Composite Workspaces use the same `open_workspace` entry point with
 `kind="composite"` and a human-readable `name`. They have no filesystem root of

package/docs/roadmap.md

@@ -305,7 +305,11 @@ must be published successfully before work begins on the next stage.
   allowlist-based read-only inspection of other Workspaces and their safe Task
   projections;
 - **0.8.5** — verify the complete contract across Workspace Relay and publish the
-  accepted 0.8 lifecycle/Task model.
+  accepted 0.8 lifecycle/Task model;
+- **0.8.7** — make `open_workspace(context="auto")` bootstrap delivery component-level,
+  returning only changed/removed AGENTS, nested-instruction, Skill/diagnostic,
+  Capability-guide, or Subagent-profile domains while preserving `full`/`none`,
+  Composite member, Relay, and legacy delivery-record semantics.
 
 The release boundary is part of the dependency graph, not just a documentation
 milestone: the next stage remains blocked until the previous version's tag-triggered

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",