@akira-tl/forgerelay 0.3.5 → 0.3.7

package/dist/workspaces.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { mkdir, opendir, readFile, realpath, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
@@ -11,6 +11,7 @@ import { loadLocalAgentProfiles, } from "./local-agent-profiles.js";
 const WORKSPACE_STALE_REMINDER_MS = 2 * 24 * 60 * 60 * 1_000;
 const WORKSPACE_SESSION_IDLE_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 const WORKSPACE_GC_INTERVAL_MS = 60 * 60 * 1_000;
+const INITIAL_INSTRUCTION_DISCOVERY_DEPTH = 1;
 export class WorkspaceRegistry {
     config;
     store;
@@ -24,11 +25,15 @@ export class WorkspaceRegistry {
         this.hooks = new HookRunner(config.hooks, config.logging);
         this.pruneIdleWorkspaceSessions(new Set(), true);
     }
+    get cachedWorkspaceCount() {
+        return this.workspaces.size;
+    }
     async openWorkspace(input, openOptions = {}) {
         this.pruneIdleWorkspaceSessions(openOptions.protectedWorkspaceIds ?? new Set());
         const workspaceInput = typeof input === "string" ? { path: input } : input;
+        const bootstrapContext = workspaceInput.context ?? "auto";
         if (workspaceInput.workspaceId) {
-            return this.resumeWorkspace(workspaceInput.workspaceId, openOptions.conversationScopeId);
+            return this.resumeWorkspace(workspaceInput.workspaceId, openOptions.conversationScopeId, bootstrapContext);
         }
         if (!workspaceInput.path) {
             throw new Error("open_workspace requires either path or workspaceId.");
@@ -37,24 +42,138 @@ export class WorkspaceRegistry {
         if (mode === "worktree") {
             return this.openReusableWorktree(workspaceInput, openOptions.conversationScopeId);
         }
-        return this.openReusableCheckout(workspaceInput.path, openOptions.conversationScopeId, workspaceInput.newWorkspace ?? false);
+        return this.openReusableCheckout(workspaceInput.path, openOptions.conversationScopeId, workspaceInput.newWorkspace ?? false, bootstrapContext);
     }
-    async resumeWorkspace(workspaceId, conversationScopeId) {
+    async listWorkspaces(input = {}, openOptions = {}) {
+        this.pruneIdleWorkspaceSessions(openOptions.protectedWorkspaceIds ?? new Set());
+        const now = Date.now();
+        const sessions = this.store
+            ? this.store.listSessions()
+            : [...this.workspaces.values()].map((workspace) => ({
+                id: workspace.id,
+                root: workspace.root,
+                status: "active",
+                mode: workspace.mode,
+                sourceRoot: workspace.sourceRoot,
+                baseRef: workspace.worktree?.baseRef,
+                baseSha: workspace.worktree?.baseSha,
+                branch: workspace.worktree?.branch,
+                targetBranch: workspace.worktree?.targetBranch,
+                managed: workspace.worktree?.managed ?? false,
+                createdAt: "",
+                lastUsedAt: "",
+            }));
+        const currentWorkspaceIds = new Set(openOptions.conversationScopeId && this.store
+            ? this.store
+                .listConversationBindings()
+                .filter((binding) => binding.conversationScopeId === openOptions.conversationScopeId)
+                .map((binding) => binding.workspaceSessionId)
+            : []);
+        const rootKey = input.root
+            ? await canonicalPath(assertAllowedPath(input.root, [...this.config.allowedRoots, this.config.worktreeRoot]))
+            : undefined;
+        const entries = await Promise.all(sessions.map(async (session) => {
+            const rootValid = await this.validSessionRoot(session) !== undefined;
+            const lastUsedAt = Date.parse(session.lastUsedAt);
+            const idleMs = Number.isFinite(lastUsedAt) ? Math.max(0, now - lastUsedAt) : 0;
+            const state = session.status !== "active"
+                ? "closed"
+                : !rootValid
+                    ? "invalid"
+                    : idleMs >= WORKSPACE_STALE_REMINDER_MS
+                        ? "stale"
+                        : "active";
+            const projectRoot = session.sourceRoot ?? session.root;
+            return {
+                label: `${basename(resolve(projectRoot)) || "workspace"}/${session.id}`,
+                workspaceId: session.id,
+                root: session.root,
+                status: session.status,
+                state,
+                mode: session.mode,
+                sourceRoot: session.sourceRoot,
+                branch: session.branch,
+                targetBranch: session.targetBranch,
+                managed: session.managed,
+                createdAt: session.createdAt,
+                lastUsedAt: session.lastUsedAt,
+                idleMs,
+                rootValid,
+                current: currentWorkspaceIds.has(session.id),
+            };
+        }));
+        const filtered = [];
+        for (let index = 0; index < sessions.length; index += 1) {
+            const session = sessions[index];
+            const entry = entries[index];
+            if (!session || !entry)
+                continue;
+            if (input.workspaceId && entry.workspaceId !== input.workspaceId)
+                continue;
+            if (input.status && entry.status !== input.status)
+                continue;
+            if (input.state && entry.state !== input.state)
+                continue;
+            if (input.mode && entry.mode !== input.mode)
+                continue;
+            if (input.staleOnly && entry.state !== "stale")
+                continue;
+            if (rootKey) {
+                const sessionRootKey = await canonicalPath(session.root);
+                const sourceRootKey = session.sourceRoot ? await canonicalPath(session.sourceRoot) : undefined;
+                if (sessionRootKey !== rootKey && sourceRootKey !== rootKey)
+                    continue;
+            }
+            filtered.push(entry);
+        }
+        const summary = filtered.reduce((counts, entry) => {
+            counts[entry.state] += 1;
+            return counts;
+        }, { active: 0, stale: 0, invalid: 0, closed: 0 });
+        const offset = Math.max(0, input.offset ?? 0);
+        const limit = Math.min(100, Math.max(1, input.limit ?? 50));
+        return {
+            workspaces: filtered.slice(offset, offset + limit),
+            summary: {
+                total: entries.length,
+                matching: filtered.length,
+                ...summary,
+            },
+            page: {
+                offset,
+                limit,
+                hasMore: offset + limit < filtered.length,
+            },
+        };
+    }
+    async resumeWorkspace(workspaceId, conversationScopeId, bootstrapContext = "auto") {
         const workspace = this.getWorkspace(workspaceId);
         const context = await this.reusedWorkspaceContext(workspace);
         if (!conversationScopeId || !this.store) {
-            return { ...context, includeBootstrapContext: true };
+            return {
+                ...context,
+                includeBootstrapContext: bootstrapContext !== "none",
+            };
         }
         const targetKeys = await this.workspaceTargetKeys(workspace);
-        const alreadyBound = targetKeys.some((targetKey) => this.store?.getConversationBinding(conversationScopeId, targetKey)?.workspaceSessionId === workspace.id);
+        const contextAlreadyDelivered = targetKeys.some((targetKey) => this.store?.getContextDelivery(conversationScopeId, targetKey)?.contextFingerprint ===
+            context.contextFingerprint);
+        const includeBootstrapContext = resolveBootstrapContextVisibility(bootstrapContext, contextAlreadyDelivered);
         for (const targetKey of targetKeys) {
             this.store.setConversationBinding({
                 conversationScopeId,
                 targetKey,
                 workspaceSessionId: workspace.id,
             });
+            if (includeBootstrapContext) {
+                this.store.setContextDelivery({
+                    conversationScopeId,
+                    targetKey,
+                    contextFingerprint: context.contextFingerprint,
+                });
+            }
         }
-        return { ...context, includeBootstrapContext: !alreadyBound };
+        return { ...context, includeBootstrapContext };
     }
     async listStaleWorkspaces(workspace) {
         if (!this.store)
@@ -206,12 +325,12 @@ export class WorkspaceRegistry {
         }
         return { ...result, hookReports };
     }
-    async openReusableCheckout(path, conversationScopeId, newWorkspace) {
+    async openReusableCheckout(path, conversationScopeId, newWorkspace, bootstrapContext) {
         const allowedPath = assertAllowedPath(path, this.config.allowedRoots);
         const projectKey = await canonicalPath(allowedPath);
         const targetKey = JSON.stringify(["checkout", projectKey, null]);
         if (!newWorkspace) {
-            const boundContext = await this.boundConversationContext(conversationScopeId, targetKey, "checkout", async (session, root) => session.mode === "checkout" && await canonicalPath(root) === projectKey);
+            const boundContext = await this.boundConversationContext(conversationScopeId, targetKey, "checkout", async (session, root) => session.mode === "checkout" && await canonicalPath(root) === projectKey, bootstrapContext);
             if (boundContext)
                 return boundContext;
         }
@@ -220,7 +339,7 @@ export class WorkspaceRegistry {
             const freshContext = reusableWorkspace
                 ? await this.cloneWorkspaceContext(reusableWorkspace)
                 : await this.openCheckoutWorkspace(path);
-            return this.withConversationContext(freshContext, conversationScopeId, targetKey);
+            return this.withConversationContext(freshContext, conversationScopeId, targetKey, bootstrapContext);
         }
         const operationKey = this.conversationOpenKey(targetKey, conversationScopeId);
         const context = await this.openOnce(operationKey, async () => {
@@ -231,18 +350,19 @@ export class WorkspaceRegistry {
                 ? this.cloneWorkspaceContext(reusableWorkspace)
                 : this.reusedWorkspaceContext(reusableWorkspace);
         });
-        return this.withConversationContext(context, conversationScopeId, targetKey);
+        return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
     }
     async openReusableWorktree(input, conversationScopeId) {
         const path = input.path;
         if (!path)
             throw new Error("Worktree mode requires path.");
+        const bootstrapContext = input.context ?? "auto";
         const managedPath = this.tryManagedWorktreePath(path);
         if (managedPath) {
             const worktreeKey = await canonicalPath(managedPath);
             const targetKey = JSON.stringify(["worktree-path", worktreeKey]);
             if (!input.newWorkspace) {
-                const boundContext = await this.boundConversationContext(conversationScopeId, targetKey, "worktree", async (session, root) => session.mode === "worktree" && await canonicalPath(root) === worktreeKey);
+                const boundContext = await this.boundConversationContext(conversationScopeId, targetKey, "worktree", async (session, root) => session.mode === "worktree" && await canonicalPath(root) === worktreeKey, bootstrapContext);
                 if (boundContext)
                     return boundContext;
             }
@@ -251,7 +371,7 @@ export class WorkspaceRegistry {
                 if (!reusableWorkspace) {
                     throw new Error(`Managed worktree is not registered as an active ForgeRelay workspace: ${managedPath}. Open the source project in worktree mode to create or recover a managed worktree first.`);
                 }
-                return this.withConversationContext(await this.cloneWorkspaceContext(reusableWorkspace), conversationScopeId, targetKey);
+                return this.withConversationContext(await this.cloneWorkspaceContext(reusableWorkspace), conversationScopeId, targetKey, bootstrapContext);
             }
             const operationKey = this.conversationOpenKey(targetKey, conversationScopeId);
             const context = await this.openOnce(operationKey, async () => {
@@ -263,7 +383,7 @@ export class WorkspaceRegistry {
                     ? this.cloneWorkspaceContext(reusableWorkspace)
                     : this.reusedWorkspaceContext(reusableWorkspace);
             });
-            return this.withConversationContext(context, conversationScopeId, targetKey);
+            return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
         }
         const resolvedBase = await resolveManagedWorktreeBase({
             sourcePath: path,
@@ -274,13 +394,13 @@ export class WorkspaceRegistry {
         const targetKey = JSON.stringify(["worktree", sourceKey, resolvedBase.targetBranch]);
         if (input.newWorktree) {
             const context = await this.openWorktreeWorkspace(path, input.baseRef);
-            return this.withConversationContext(context, conversationScopeId, targetKey);
+            return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
         }
         if (!input.newWorkspace) {
             const boundContext = await this.boundConversationContext(conversationScopeId, targetKey, "worktree", async (session) => session.mode === "worktree" &&
                 session.sourceRoot !== undefined &&
                 await canonicalPath(session.sourceRoot) === sourceKey &&
-                session.targetBranch === resolvedBase.targetBranch);
+                session.targetBranch === resolvedBase.targetBranch, bootstrapContext);
             if (boundContext)
                 return boundContext;
         }
@@ -289,7 +409,7 @@ export class WorkspaceRegistry {
             const freshContext = reusableWorkspace
                 ? await this.cloneWorkspaceContext(reusableWorkspace)
                 : await this.openWorktreeWorkspace(path, input.baseRef);
-            return this.withConversationContext(freshContext, conversationScopeId, targetKey);
+            return this.withConversationContext(freshContext, conversationScopeId, targetKey, bootstrapContext);
         }
         const operationKey = this.conversationOpenKey(targetKey, conversationScopeId);
         const context = await this.openOnce(operationKey, async () => {
@@ -300,7 +420,7 @@ export class WorkspaceRegistry {
                 ? this.cloneWorkspaceContext(reusableWorkspace)
                 : this.reusedWorkspaceContext(reusableWorkspace);
         });
-        return this.withConversationContext(context, conversationScopeId, targetKey);
+        return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
     }
     async openOnce(operationKey, open) {
         const pending = this.pendingOpens.get(operationKey);
@@ -338,7 +458,7 @@ export class WorkspaceRegistry {
             ? JSON.stringify(["conversation", conversationScopeId, targetKey])
             : targetKey;
     }
-    async boundConversationContext(conversationScopeId, targetKey, mode, matches) {
+    async boundConversationContext(conversationScopeId, targetKey, mode, matches, bootstrapContext) {
         if (!conversationScopeId || !this.store)
             return undefined;
         const binding = this.store.getConversationBinding(conversationScopeId, targetKey);
@@ -359,24 +479,30 @@ export class WorkspaceRegistry {
             return undefined;
         }
         const context = await this.reusedWorkspaceContext(this.getWorkspace(session.id));
-        this.store.touchConversationBinding(conversationScopeId, targetKey);
-        return { ...context, includeBootstrapContext: false };
+        return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
     }
-    withConversationContext(context, conversationScopeId, targetKey) {
+    withConversationContext(context, conversationScopeId, targetKey, bootstrapContext) {
         if (!conversationScopeId || !this.store) {
-            return { ...context, includeBootstrapContext: true };
-        }
-        const binding = this.store.getConversationBinding(conversationScopeId, targetKey);
-        if (binding?.workspaceSessionId === context.workspace.id) {
-            this.store.touchConversationBinding(conversationScopeId, targetKey);
-            return { ...context, includeBootstrapContext: false };
+            return {
+                ...context,
+                includeBootstrapContext: bootstrapContext !== "none",
+            };
         }
+        const delivery = this.store.getContextDelivery(conversationScopeId, targetKey);
+        const includeBootstrapContext = resolveBootstrapContextVisibility(bootstrapContext, delivery?.contextFingerprint === context.contextFingerprint);
         this.store.setConversationBinding({
             conversationScopeId,
             targetKey,
             workspaceSessionId: context.workspace.id,
         });
-        return { ...context, includeBootstrapContext: true };
+        if (includeBootstrapContext) {
+            this.store.setContextDelivery({
+                conversationScopeId,
+                targetKey,
+                contextFingerprint: context.contextFingerprint,
+            });
+        }
+        return { ...context, includeBootstrapContext };
     }
     pruneIdleWorkspaceSessions(protectedWorkspaceIds, force = false) {
         if (!this.store)
@@ -397,6 +523,13 @@ export class WorkspaceRegistry {
                 this.store.deleteConversationBinding(binding.conversationScopeId, binding.targetKey);
             }
         }
+        for (const delivery of this.store.listContextDeliveries()) {
+            const deliveredAt = Date.parse(delivery.deliveredAt);
+            if (Number.isFinite(deliveredAt) &&
+                now - deliveredAt >= WORKSPACE_SESSION_IDLE_TTL_MS) {
+                this.store.deleteContextDelivery(delivery.conversationScopeId, delivery.targetKey);
+            }
+        }
         const boundWorkspaceIds = new Set(this.store.listConversationBindings().map((binding) => binding.workspaceSessionId));
         const worktreeAnchors = new Map();
         for (const session of activeSessions) {
@@ -499,13 +632,20 @@ export class WorkspaceRegistry {
         });
     }
     async reusedWorkspaceContext(workspace) {
+        Object.assign(workspace, this.loadSkillsForWorkspace(workspace.root));
+        workspace.capabilityGuides = loadCapabilityGuides(this.config);
         workspace.agentProfiles = await loadLocalAgentProfiles(this.config, workspace.root);
-        const agentsFiles = await this.loadInitialAgentsFiles(workspace.root);
-        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace.root, agentsFiles);
+        workspace.scannedInstructionDirs.clear();
+        workspace.knownInstructionPathsByDir.clear();
+        workspace.loadedInstructionRealPaths.clear();
+        const agentsFiles = await this.loadInitialAgentsFiles(workspace);
+        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
+        const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
             agentsFiles,
             availableAgentsFiles,
+            contextFingerprint,
             hookReports: [],
             workspaceReused: true,
             includeBootstrapContext: true,
@@ -553,6 +693,9 @@ export class WorkspaceRegistry {
             agentProfiles: [],
             activatedSkillDirs: new Set(),
             activatedCapabilityGuideDirs: new Set(),
+            scannedInstructionDirs: new Set(),
+            knownInstructionPathsByDir: new Map(),
+            loadedInstructionRealPaths: new Set(),
         };
         if (touch)
             this.store?.touchSession(session.id);
@@ -649,6 +792,9 @@ export class WorkspaceRegistry {
             agentProfiles: await loadLocalAgentProfiles(this.config, input.root),
             activatedSkillDirs: new Set(),
             activatedCapabilityGuideDirs: new Set(),
+            scannedInstructionDirs: new Set(),
+            knownInstructionPathsByDir: new Map(),
+            loadedInstructionRealPaths: new Set(),
         };
         this.store?.createSession({
             id: workspace.id,
@@ -674,12 +820,14 @@ export class WorkspaceRegistry {
                 targetBranch: workspace.worktree?.targetBranch,
             },
         });
-        const agentsFiles = await this.loadInitialAgentsFiles(workspace.root);
-        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace.root, agentsFiles);
+        const agentsFiles = await this.loadInitialAgentsFiles(workspace);
+        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
+        const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
             agentsFiles,
             availableAgentsFiles,
+            contextFingerprint,
             hookReports,
             workspaceReused: false,
             includeBootstrapContext: true,
@@ -702,11 +850,9 @@ export class WorkspaceRegistry {
         }
         return assertAllowedPath(root, this.config.allowedRoots);
     }
-    async loadInitialAgentsFiles(root) {
-        const resolvedRoot = (await tryRealpath(root)) ?? root;
+    async loadInitialAgentsFiles(workspace) {
         const systemInstructionsPath = resolve(this.config.systemInstructionsPath);
         const loadedFiles = [];
-        const loadedRealPaths = new Set();
         const systemInstructions = await readSystemInstructions(systemInstructionsPath);
         const systemInstructionsRealPath = await tryRealpath(systemInstructionsPath);
         if (systemInstructions !== undefined) {
@@ -714,52 +860,170 @@ export class WorkspaceRegistry {
                 path: systemInstructionsPath,
                 content: systemInstructions,
             });
-            if (systemInstructionsRealPath)
-                loadedRealPaths.add(systemInstructionsRealPath);
-        }
-        for (const fileName of CONTEXT_FILE_NAMES) {
-            const path = join(root, fileName);
-            const content = await readResolvedProjectContextFile(path, resolvedRoot);
-            if (content === undefined)
-                continue;
-            const realPath = await tryRealpath(path);
-            if (realPath && loadedRealPaths.has(realPath))
-                continue;
-            loadedFiles.push({
-                path,
-                content,
-            });
-            if (realPath)
-                loadedRealPaths.add(realPath);
+            if (systemInstructionsRealPath) {
+                workspace.loadedInstructionRealPaths.add(systemInstructionsRealPath);
+            }
         }
+        await this.discoverInstructionTree(workspace, workspace.root, INITIAL_INSTRUCTION_DISCOVERY_DEPTH);
+        loadedFiles.push(...await this.loadKnownInstructionsInDirectory(workspace, workspace.root));
         return loadedFiles;
     }
-    async findAvailableAgentsFiles(root, loadedFiles) {
+    async findAvailableAgentsFiles(workspace, loadedFiles) {
         const loadedPaths = new Set(loadedFiles.map((file) => resolve(file.path)));
-        const loadedRealPaths = new Set();
-        for (const file of loadedFiles) {
-            const realPath = await tryRealpath(file.path);
-            if (realPath)
-                loadedRealPaths.add(realPath);
-        }
         const discovered = [];
-        const agentDir = resolve(this.config.agentDir);
-        await walkWorkspace(root, async (path, entry) => {
-            if (isPathInsideRoot(path, agentDir))
-                return;
-            if (!entry.isFile())
-                return;
-            if (!CONTEXT_FILE_NAMES.has(entry.name))
-                return;
-            if (loadedPaths.has(path))
-                return;
-            const realPath = await tryRealpath(path);
-            if (realPath && loadedRealPaths.has(realPath))
-                return;
-            discovered.push({ path });
-        });
+        for (const paths of workspace.knownInstructionPathsByDir.values()) {
+            for (const path of paths) {
+                if (loadedPaths.has(path))
+                    continue;
+                const realPath = await tryRealpath(path);
+                if (realPath && workspace.loadedInstructionRealPaths.has(realPath))
+                    continue;
+                discovered.push({ path });
+            }
+        }
         return discovered.sort((a, b) => a.path.localeCompare(b.path));
     }
+    async discoverPathInstructions(workspace, inputPath) {
+        const absolutePath = resolve(inputPath);
+        if (!isPathInsideRoot(absolutePath, workspace.root))
+            return [];
+        const targetDirectory = dirname(absolutePath);
+        const relationship = relative(workspace.root, targetDirectory);
+        if (relationship === ".." ||
+            relationship.startsWith(`..${sep}`) ||
+            resolve(targetDirectory) === resolve(this.config.agentDir) ||
+            isPathInsideRoot(targetDirectory, resolve(this.config.agentDir))) {
+            return [];
+        }
+        const directories = [resolve(workspace.root)];
+        if (relationship) {
+            let current = resolve(workspace.root);
+            for (const segment of relationship.split(sep).filter(Boolean)) {
+                if (SKIPPED_CONTEXT_DIRS.has(segment))
+                    break;
+                current = join(current, segment);
+                directories.push(current);
+            }
+        }
+        const loaded = [];
+        for (const directory of directories) {
+            await this.discoverInstructionTree(workspace, directory, 0);
+            loaded.push(...await this.loadKnownInstructionsInDirectory(workspace, directory));
+        }
+        return loaded;
+    }
+    async discoverInstructionTree(workspace, directory, remainingDepth) {
+        const resolvedDirectory = resolve(directory);
+        if (workspace.scannedInstructionDirs.has(resolvedDirectory))
+            return;
+        workspace.scannedInstructionDirs.add(resolvedDirectory);
+        if (resolvedDirectory !== resolve(workspace.root) &&
+            isPathInsideRoot(resolvedDirectory, resolve(this.config.agentDir))) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await opendir(resolvedDirectory);
+        }
+        catch {
+            return;
+        }
+        const instructionPaths = [];
+        const childDirectories = [];
+        for await (const entry of entries) {
+            const path = join(resolvedDirectory, entry.name);
+            if (entry.isFile() && CONTEXT_FILE_NAMES.has(entry.name)) {
+                instructionPaths.push(path);
+                continue;
+            }
+            if (remainingDepth > 0 &&
+                entry.isDirectory() &&
+                !SKIPPED_CONTEXT_DIRS.has(entry.name)) {
+                childDirectories.push(path);
+            }
+        }
+        workspace.knownInstructionPathsByDir.set(resolvedDirectory, instructionPaths.sort((left, right) => left.localeCompare(right)));
+        if (remainingDepth <= 0)
+            return;
+        for (const childDirectory of childDirectories) {
+            await this.discoverInstructionTree(workspace, childDirectory, remainingDepth - 1);
+        }
+    }
+    async loadKnownInstructionsInDirectory(workspace, directory) {
+        const resolvedDirectory = resolve(directory);
+        const paths = workspace.knownInstructionPathsByDir.get(resolvedDirectory) ?? [];
+        const loaded = [];
+        const resolvedRoot = (await tryRealpath(workspace.root)) ?? resolve(workspace.root);
+        const realDirectory = (await tryRealpath(resolvedDirectory)) ?? resolvedDirectory;
+        for (const path of paths) {
+            const realPath = await tryRealpath(path);
+            if (!realPath)
+                continue;
+            if (!isPathInsideRoot(realPath, resolvedRoot))
+                continue;
+            if (dirname(realPath) !== realDirectory)
+                continue;
+            if (workspace.loadedInstructionRealPaths.has(realPath))
+                continue;
+            let content;
+            try {
+                content = await readFile(realPath, "utf8");
+            }
+            catch (error) {
+                if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+                    continue;
+                throw error;
+            }
+            workspace.loadedInstructionRealPaths.add(realPath);
+            loaded.push({ path, content });
+        }
+        return loaded;
+    }
+}
+function resolveBootstrapContextVisibility(mode, contextAlreadyDelivered) {
+    if (mode === "full")
+        return true;
+    if (mode === "none")
+        return false;
+    return !contextAlreadyDelivered;
+}
+function bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles) {
+    const payload = {
+        agentsFiles: agentsFiles
+            .map((file) => ({ path: resolve(file.path), content: file.content }))
+            .sort((left, right) => left.path.localeCompare(right.path)),
+        availableAgentsFiles: availableAgentsFiles
+            .map((file) => resolve(file.path))
+            .sort((left, right) => left.localeCompare(right)),
+        skills: workspace.skills
+            .map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+            filePath: resolve(skill.filePath),
+            disableModelInvocation: skill.disableModelInvocation ?? false,
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name) || left.filePath.localeCompare(right.filePath)),
+        skillDiagnostics: workspace.skillDiagnostics,
+        capabilityGuides: workspace.capabilityGuides
+            .map((guide) => ({
+            name: guide.name,
+            description: guide.description,
+            whenToRead: guide.whenToRead,
+            filePath: resolve(guide.filePath),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name)),
+        agentProfiles: workspace.agentProfiles
+            .map((profile) => ({
+            name: profile.name,
+            description: profile.description,
+            provider: profile.provider,
+            model: profile.model,
+            thinking: profile.thinking,
+            filePath: resolve(profile.filePath),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name)),
+    };
+    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 async function canonicalPath(path) {
     const missingSegments = [];
@@ -818,9 +1082,6 @@ export function formatAgentsPath(path, workspaceRoot) {
     }
     return relationship.split(sep).join("/");
 }
-function isProjectRootInstructionPath(path, root) {
-    return isPathInsideRoot(path, root) && dirname(path) === root;
-}
 async function readSystemInstructions(path) {
     try {
         return await readFile(path, "utf8");
@@ -832,20 +1093,6 @@ async function readSystemInstructions(path) {
         throw error;
     }
 }
-async function readResolvedProjectContextFile(path, root) {
-    try {
-        const resolvedPath = await realpath(path);
-        if (!isProjectRootInstructionPath(resolvedPath, root))
-            return undefined;
-        return await readFile(resolvedPath, "utf8");
-    }
-    catch (error) {
-        if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
-            return undefined;
-        }
-        throw error;
-    }
-}
 async function tryRealpath(path) {
     try {
         return await realpath(path);
@@ -854,25 +1101,6 @@ async function tryRealpath(path) {
         return undefined;
     }
 }
-async function walkWorkspace(directory, visit) {
-    let entries;
-    try {
-        entries = await opendir(directory);
-    }
-    catch {
-        return;
-    }
-    for await (const entry of entries) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            if (!SKIPPED_CONTEXT_DIRS.has(entry.name)) {
-                await walkWorkspace(path, visit);
-            }
-            continue;
-        }
-        await visit(path, entry);
-    }
-}
 function isErrnoException(error) {
     return error instanceof Error && "code" in error;
 }