@botbotgo/agent-harness 0.0.135 → 0.0.136

package/dist/config/agents/orchestra.yaml

@@ -1,7 +1,7 @@
 # agent-harness feature: schema version for this declarative config object.
 apiVersion: agent-harness/v1alpha1
 # agent-harness feature: object type discriminator.
-# Prefer the generic `Agent` form and select the concrete execution backend under `spec.execution`.
+# Prefer the generic `Agent` form and place execution fields directly under `spec`.
 kind: Agent
 metadata:
   # agent-harness feature: stable object id used for refs and runtime naming.
@@ -19,99 +19,98 @@ spec:
   # =====================
   # Runtime Agent Features
   # =====================
-  execution:
-    # Current backend adapter for this host profile.
-    backend: deepagent
-    # Upstream execution feature: model ref for the underlying LLM used by this execution host.
-    modelRef: model/default
-    memory:
-      # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
-      # These paths resolve relative to the workspace root unless they are already absolute.
-      # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
-      # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
-      # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
-      # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
-      # - use the harness checkpointer for resumable graph state for an in-flight run
-      # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
-      # self-updating runtime memory.
-      - path: config/agent-context.md
-    # Upstream execution feature: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
-    tools: []
-    # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
-    skills: []
-    # Upstream execution feature: subagent topology is empty in the repository default and can be filled in YAML.
-    subagents: []
-    # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
-    mcpServers: []
-    # Runtime execution feature: checkpointer config passed into the selected backend adapter.
-    # This persists resumable graph state for this agent.
-    # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
-    # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
-    checkpointer:
-      ref: checkpointer/sqlite
-    # Upstream execution feature: store config passed into the selected backend adapter.
-    # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
-    # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.
-    # Other store kinds should flow through a custom runtime resolver instead of being claimed as built in.
-    store:
-      ref: store/default
+  # Current backend adapter for this host profile.
+  backend: deepagent
+  # Upstream execution feature: model ref for the underlying LLM used by this execution host.
+  modelRef: model/default
+  memory:
+    # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
+    # These paths resolve relative to the workspace root unless they are already absolute.
+    # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
+    # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
+    # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
+    # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
+    # - use the harness checkpointer for resumable graph state for an in-flight run
+    # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
+    # self-updating runtime memory.
+    - path: config/agent-context.md
+  # Upstream execution feature: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
+  tools: []
+  # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
+  skills: []
+  # Upstream execution feature: subagent topology is empty in the repository default and can be filled in YAML.
+  subagents: []
+  # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
+  mcpServers: []
+  # Runtime execution feature: checkpointer config passed into the selected backend adapter.
+  # This persists resumable graph state for this agent.
+  # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
+  # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
+  checkpointer:
+    ref: checkpointer/sqlite
+  # Upstream execution feature: store config passed into the selected backend adapter.
+  # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
+  # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.
+  # Other store kinds should flow through a custom runtime resolver instead of being claimed as built in.
+  store:
+    ref: store/default
+  # Upstream execution feature: backend config passed into the selected backend adapter.
+  # Prefer a reusable backend preset via `ref` so backend topology stays declarative and reusable in YAML.
+  # The default preset keeps DeepAgent execution semantics upstream-owned:
+  # - workspace execution uses a lightweight VFS sandbox
+  # - long-term memory under `/memories/*` uses `StoreBackend`
+  # - `CompositeBackend` composes those backend instances together
+  # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
+  # Upstream execution feature: no extra declarative HITL rules by default.
+  interruptOn: {}
+  # Upstream execution feature: no extra declarative middleware beyond upstream deepagents defaults by default.
+  # Common upstream middleware kinds that this harness can compile directly from YAML:
+  # - `patchToolCalls`
+  # - `summarization`
+  # - `dynamicSystemPrompt`
+  # - `humanInTheLoop`
+  # - `todoList`
+  # - `pii`, `piiRedaction`
+  #
+  # DeepAgents already includes its own filesystem, planning, subagent, and memory semantics.
+  # Keep this list empty unless you are intentionally adding extra upstream middleware on top.
+  middleware: []
+  config:
     # Upstream execution feature: backend config passed into the selected backend adapter.
-    # Prefer a reusable backend preset via `ref` so backend topology stays declarative and reusable in YAML.
-    # The default preset keeps DeepAgent execution semantics upstream-owned:
-    # - workspace execution uses a lightweight VFS sandbox
-    # - long-term memory under `/memories/*` uses `StoreBackend`
-    # - `CompositeBackend` composes those backend instances together
-    # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
-    # Upstream execution feature: no extra declarative HITL rules by default.
-    interruptOn: {}
-    # Upstream execution feature: no extra declarative middleware beyond upstream deepagents defaults by default.
-    # Common upstream middleware kinds that this harness can compile directly from YAML:
-    # - `patchToolCalls`
-    # - `summarization`
-    # - `dynamicSystemPrompt`
-    # - `humanInTheLoop`
-    # - `todoList`
-    # - `pii`, `piiRedaction`
-    #
-    # DeepAgents already includes its own filesystem, planning, subagent, and memory semantics.
-    # Keep this list empty unless you are intentionally adding extra upstream middleware on top.
-    middleware: []
-    config:
-      # Upstream execution feature: backend config passed into the selected backend adapter.
-      # Keep this nested under `config` because `execution.backend` already selects the adapter mode.
-      backend:
-        ref: backend/default
-    # Upstream execution feature: system prompt for the orchestration host.
-    # This becomes the top-level instruction block for the selected execution backend and should hold the
-    # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
-    systemPrompt: |-
-      You are the orchestra agent.
+    # Keep this nested under `config` because `backend` already selects the adapter mode.
+    backend:
+      ref: backend/default
+  # Upstream execution feature: system prompt for the orchestration host.
+  # This becomes the top-level instruction block for the selected execution backend and should hold the
+  # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
+  systemPrompt: |-
+    You are the orchestra agent.
 
-      You are the default execution host.
-      Try to finish the request yourself before delegating.
-      Use your own tools first when they are sufficient.
-      Use your own skills first when they are sufficient.
-      Delegate only when a subagent is a clearly better fit or when your own tools and skills are not enough.
-      If neither you nor any suitable subagent can do the work, say so plainly.
+    You are the default execution host.
+    Try to finish the request yourself before delegating.
+    Use your own tools first when they are sufficient.
+    Use your own skills first when they are sufficient.
+    Delegate only when a subagent is a clearly better fit or when your own tools and skills are not enough.
+    If neither you nor any suitable subagent can do the work, say so plainly.
 
-      Do not delegate by reflex.
-      Do not delegate just because a task has multiple steps.
-      Do not delegate when a direct answer or a short local tool pass is enough.
-      Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
-      the most appropriate subagent.
+    Do not delegate by reflex.
+    Do not delegate just because a task has multiple steps.
+    Do not delegate when a direct answer or a short local tool pass is enough.
+    Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
+    the most appropriate subagent.
 
-      Use your own tools for lightweight discovery, inventory, and context gathering.
-      Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
-      ad hoc shell work when those tools are sufficient.
-      Use the attached subagent descriptions as the source of truth for what each subagent is for.
-      Do not delegate to a subagent whose description does not clearly match the task.
-      Integrate subagent results into one coherent answer and do not claim checks or evidence you did not obtain.
+    Use your own tools for lightweight discovery, inventory, and context gathering.
+    Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
+    ad hoc shell work when those tools are sufficient.
+    Use the attached subagent descriptions as the source of truth for what each subagent is for.
+    Do not delegate to a subagent whose description does not clearly match the task.
+    Integrate subagent results into one coherent answer and do not claim checks or evidence you did not obtain.
 
-      When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
-      inferring from memory.
+    When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
+    inferring from memory.
 
-      Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
-      to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
-      ownership facts are good candidates.
-      Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
-      outputs that can be cheaply recomputed.
+    Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
+    to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
+    ownership facts are good candidates.
+    Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
+    outputs that can be cheaply recomputed.

package/dist/contracts/workspace.d.ts

@@ -249,7 +249,7 @@ export type CompiledAgentBinding = {
 };
 export type WorkspaceBundle = {
     workspaceRoot: string;
-    resourceSources: string[];
+    resources: string[];
     refs: Map<string, WorkspaceObject | ParsedAgentObject>;
     models: Map<string, ParsedModelObject>;
     embeddings: Map<string, ParsedEmbeddingModelObject>;
@@ -267,5 +267,5 @@ export type WorkspaceLoadOptions = {
      * Later values always override earlier values.
      */
     overlayRoots?: string[];
-    resourceSources?: string[];
+    resources?: string[];
 };

package/dist/extensions.js

@@ -15,7 +15,7 @@ function resolveToolRefId(ref) {
     if (ref.startsWith("builtin/")) {
         return ref;
     }
-    return ref.split("/").slice(1).join("/");
+    return ref.includes("/") ? ref.split("/").slice(1).join("/") : ref;
 }
 export function resolveToolTargets(tools, ref) {
     const resolved = resolveToolRefId(ref);
@@ -28,6 +28,10 @@ export function resolveToolTargets(tools, ref) {
     if (exact) {
         return [exact];
     }
+    const byName = Array.from(tools.values()).filter((tool) => tool.name === resolved);
+    if (byName.length > 0) {
+        return byName;
+    }
     if (!resolved.startsWith("builtin/")) {
         return [];
     }

package/dist/init-project.js

@@ -190,8 +190,8 @@ spec:
 `;
 }
 function renderResearchAgentYaml(options) {
-    const toolsBlock = options.withWebSearch ? "    tools:\n      - ref: tool/web-search\n" : "    tools: []\n";
-    const subagentsBlock = options.template === "deep-research" ? "    subagents:\n      - ref: agent/research-analyst\n" : "    subagents: []\n";
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
+    const subagentsBlock = options.template === "deep-research" ? "  subagents:\n    - ref: agent/research-analyst\n" : "  subagents: []\n";
     const prompt = options.withWebSearch
         ? "Break complex research requests into a clear plan, use web search when current information matters, and return a concise synthesis with sources and explicit uncertainty."
         : "Break complex research requests into a clear plan and return a concise synthesis with explicit assumptions and uncertainty.";
@@ -207,19 +207,18 @@ spec:
   runtime:
     runtimeMemory:
       ref: runtime-memory/default
-  execution:
-    backend: deepagent
-    modelRef: model/default
-${toolsBlock}    skills:
-      - path: ./
-${subagentsBlock}    config:
-      backend:
-        ref: backend/default
-    systemPrompt: ${prompt}${delegationLine}
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - deep-research
+${subagentsBlock}  config:
+    backend:
+      ref: backend/default
+  systemPrompt: ${prompt}${delegationLine}
 `;
 }
 function renderResearchAnalystYaml(options) {
-    const toolsBlock = options.withWebSearch ? "    tools:\n      - ref: tool/web-search\n" : "    tools: []\n";
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
     const prompt = options.withWebSearch
         ? "Gather current sources, compare claims carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize."
         : "Break down the problem, compare alternatives carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize.";
@@ -232,15 +231,14 @@ spec:
   runtime:
     runtimeMemory:
       ref: runtime-memory/default
-  execution:
-    backend: deepagent
-    modelRef: model/default
-${toolsBlock}    skills:
-      - path: ./
-    config:
-      backend:
-        ref: backend/default
-    systemPrompt: ${prompt}
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - deep-research
+  config:
+    backend:
+      ref: backend/default
+  systemPrompt: ${prompt}
 `;
 }
 function renderResourcePackageJson(projectSlug) {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.134";
+export declare const AGENT_HARNESS_VERSION = "0.0.135";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.134";
+export const AGENT_HARNESS_VERSION = "0.0.135";

package/dist/resource/resource-impl.js

@@ -266,7 +266,7 @@ function readStringRecord(value) {
     return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
 function listWorkspaceResourceProviders(workspace) {
-    return (workspace.resourceSources ?? [])
+    return (workspace.resources ?? [])
         .map((source) => remoteResourceCache.get(source))
         .filter((provider) => Boolean(provider));
 }

package/dist/tool-modules.d.ts

@@ -7,7 +7,12 @@ export type LoadedToolModule = {
     description: string;
     retryable?: boolean;
 };
+export type LoadedSkillModule = {
+    name: string;
+    description?: string;
+};
 export declare function isSupportedToolModulePath(filePath: string): boolean;
 export declare function discoverToolModuleDefinitions(_sourceText: string, imported: ImportedToolModule): LoadedToolModule[];
 export declare function loadToolModuleDefinition(imported: ImportedToolModule, implementationName: string): LoadedToolModule;
+export declare function discoverSkillDefinitions(skillRoots: string[]): LoadedSkillModule[];
 export {};

package/dist/tool-modules.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { readSkillMetadata } from "./runtime/support/skill-metadata.js";
 import { TOOL_DEFINITION_MARKER, normalizeToolSchema } from "./tools.js";
 const TOOL_MODULE_EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
 function isToolDefinitionObject(value) {
@@ -40,3 +41,12 @@ export function loadToolModuleDefinition(imported, implementationName) {
     }
     throw new Error(`Tool module must export a tool({...}) definition named ${implementationName}.`);
 }
+export function discoverSkillDefinitions(skillRoots) {
+    return skillRoots.map((skillRoot) => {
+        const metadata = readSkillMetadata(skillRoot);
+        return {
+            name: metadata.name || path.basename(skillRoot),
+            description: metadata.description,
+        };
+    });
+}

package/dist/workspace/compile.js

@@ -1,11 +1,16 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { ensureResourceSources } from "../resource/resource.js";
-import { loadWorkspaceObjects } from "./object-loader.js";
+import { ensureExternalResourceSource, isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
+import { loadWorkspaceObjects, readToolModuleItems, readYamlItems } from "./object-loader.js";
+import { validateSkillMetadata } from "../runtime/support/skill-metadata.js";
 import { parseEmbeddingModelObject, parseMcpServerObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateMcpServerObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
 import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { getRoutingDefaultAgentId, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRuntimeResources, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
@@ -93,6 +98,109 @@ function validateRoutingTargets(refs, agentsList) {
         }
     }
 }
+function resolveLocalResourceRoot(candidate, workspaceRoot) {
+    const resolved = path.resolve(workspaceRoot, candidate);
+    const resourceRoot = resolveResourcePackageRoot(resolved);
+    if (!resourceRoot) {
+        throw new Error(`Workspace resource ${candidate} is missing resources/package.json.`);
+    }
+    return resourceRoot;
+}
+async function resolveConfiguredResources(entries, workspaceRoot) {
+    const resolved = [];
+    for (const entry of entries) {
+        const key = entry.trim();
+        if (!key) {
+            continue;
+        }
+        const root = isExternalSourceLocator(key)
+            ? await ensureExternalResourceSource(key, workspaceRoot)
+            : resolveLocalResourceRoot(key, workspaceRoot);
+        resolved.push({ key, root });
+    }
+    return resolved;
+}
+async function registerAttachedResourceTools(tools, resourceRoot) {
+    const toolsRoot = path.join(resourceRoot, "tools");
+    for (const { item, sourcePath } of await readYamlItems(toolsRoot, undefined, { recursive: true })) {
+        const parsed = parseToolObject({
+            id: typeof item.id === "string" ? item.id : path.basename(sourcePath).replace(/\.(yaml|yml|json)$/i, ""),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, parsed);
+    }
+    for (const { item, sourcePath } of await readToolModuleItems(toolsRoot)) {
+        const parsed = parseToolObject({
+            id: String(item.id),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, parsed);
+    }
+}
+async function collectSkillRoots(root) {
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        const skillDocument = entries.find((entry) => entry.isFile() && entry.name === "SKILL.md");
+        if (skillDocument) {
+            return [root];
+        }
+        const nested = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => collectSkillRoots(path.join(root, entry.name))));
+        return nested.flat();
+    }
+    catch {
+        return [];
+    }
+}
+async function registerWorkspaceSkillRegistry(skillCollectionRoots) {
+    const registry = new Map();
+    for (const skillsRoot of skillCollectionRoots) {
+        for (const skillRoot of await collectSkillRoots(skillsRoot)) {
+            const metadata = validateSkillMetadata(skillRoot);
+            const existing = registry.get(metadata.name);
+            if (existing && existing !== skillRoot) {
+                throw new Error(`Duplicate skill name ${metadata.name} found in ${existing} and ${skillRoot}`);
+            }
+            registry.set(metadata.name, skillRoot);
+        }
+    }
+    return registry;
+}
+function validateToolNameConflicts(tools) {
+    const seen = new Map();
+    for (const tool of tools.values()) {
+        const existing = seen.get(tool.name);
+        if (existing && existing !== tool.sourcePath) {
+            throw new Error(`Duplicate tool name ${tool.name} found in ${existing} and ${tool.sourcePath}`);
+        }
+        seen.set(tool.name, tool.sourcePath);
+    }
+}
+function resolveAgentSkillNames(agents, skillRegistry, skillCollectionRoots) {
+    for (const agent of agents) {
+        agent.skillPathRefs = agent.skillPathRefs.map((entry) => {
+            const registered = skillRegistry.get(entry);
+            if (registered) {
+                return registered;
+            }
+            if (path.isAbsolute(entry) || entry.includes("/") || entry.startsWith("builtin://")) {
+                return entry;
+            }
+            for (const skillsRoot of skillCollectionRoots) {
+                const candidate = path.join(skillsRoot, entry);
+                if (existsSync(path.join(candidate, "SKILL.md"))) {
+                    return candidate;
+                }
+            }
+            return entry;
+        });
+    }
+}
 export async function loadWorkspace(workspaceRoot, options = {}) {
     const loaded = await loadWorkspaceObjects(workspaceRoot, options);
     loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
@@ -102,20 +210,40 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
-    for (const agent of loaded.agents) {
-        for (const tool of agent.inlineTools ?? []) {
-            tools.set(tool.id, tool);
-        }
-    }
     await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
-    const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
-    await ensureResourceSources(toolSourceRefs, workspaceRoot);
-    await hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot);
+    const configuredResources = Array.from(new Set([
+        ...getRuntimeResources(loaded.refs),
+        ...(options.resources ?? []),
+    ]));
+    const resolvedConfiguredResources = await resolveConfiguredResources(configuredResources, workspaceRoot);
+    for (const resource of resolvedConfiguredResources) {
+        await registerAttachedResourceTools(tools, resource.root);
+    }
+    const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
+    const skillCollectionRoots = [
+        path.join(workspaceRoot, "modules", "skills"),
+        ...(localResourceRoot ? [path.join(localResourceRoot, "skills")] : []),
+        ...resolvedConfiguredResources.map((resource) => path.join(resource.root, "skills")),
+    ];
+    const skillRegistry = await registerWorkspaceSkillRegistry(skillCollectionRoots);
+    resolveAgentSkillNames(loaded.agents, skillRegistry, skillCollectionRoots);
+    const collectedResources = collectToolSourceRefs(tools, loaded.agents, {
+        ...options,
+        resources: configuredResources,
+    });
+    const externalResources = collectedResources.filter((resource) => isExternalSourceLocator(resource));
+    await ensureResourceSources(externalResources, workspaceRoot);
+    await hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot);
+    validateToolNameConflicts(tools);
+    const resources = Array.from(new Set([
+        ...(localResourceRoot ? [localResourceRoot] : []),
+        ...collectedResources,
+    ]));
     validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
     validateRoutingTargets(loaded.refs, loaded.agents);
     return {
         workspaceRoot,
-        resourceSources: [...toolSourceRefs],
+        resources,
         refs: loaded.refs,
         embeddings,
         mcpServers,