@botbotgo/agent-harness 0.0.155 → 0.0.157

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemorizeInput, MemorizeResult, RecallInput, RecallResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -70,6 +70,9 @@ export declare class AgentHarnessRuntime {
     }): Promise<RunSummary[]>;
     memorize(input: MemorizeInput): Promise<MemorizeResult>;
     recall(input: RecallInput): Promise<RecallResult>;
+    listMemories(input?: ListMemoriesInput): Promise<ListMemoriesResult>;
+    updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
+    removeMemory(input: RemoveMemoryInput): Promise<MemoryRecord>;
     getRun(runId: string): Promise<RunRecord | null>;
     private getSession;
     getThread(threadId: string): Promise<ThreadRecord | null>;
@@ -79,6 +82,10 @@ export declare class AgentHarnessRuntime {
         runId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
+    exportEvaluationBundle(input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
     listAgentSkills(agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
     getAgent(agentId: string, options?: RequirementAssessmentOptions): InventoryAgentRecord | null;
     describeWorkspaceInventory(options?: RequirementAssessmentOptions): {
@@ -102,6 +109,8 @@ export declare class AgentHarnessRuntime {
     private invokeWithHistory;
     private resolveMemoryNamespace;
     private getWorkspaceId;
+    private summarizeMemoryContent;
+    private matchesMemoryFilters;
     private resolveRecallScopes;
     private matchesRecallScope;
     private getMemoryScopeBoost;
@@ -113,6 +122,7 @@ export declare class AgentHarnessRuntime {
     private createMem0MemoryRecord;
     private rankRecallCandidates;
     private rebuildRuntimeMemoryVectorIndex;
+    private refreshStructuredMemoryScope;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
     private persistStructuredMemoryCandidates;

package/dist/runtime/harness.js

@@ -31,7 +31,7 @@ import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnab
 import { Mem0IngestionSync, Mem0SemanticRecall, readMem0RuntimeConfig, } from "./harness/system/mem0-ingestion-sync.js";
 import { createRuntimeMemoryManager, RuntimeMemoryFormationSync, readRuntimeMemoryFormationConfig, } from "./harness/system/runtime-memory-manager.js";
 import { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.js";
-import { getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, } from "./harness/system/runtime-memory-records.js";
+import { findMemoryRecordById, getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, removeMemoryRecord, updateMemoryRecord, } from "./harness/system/runtime-memory-records.js";
 import { consolidateStructuredMemoryScope } from "./harness/system/runtime-memory-consolidation.js";
 import { normalizeLangMemMemoryKind, readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
@@ -361,6 +361,98 @@ export class AgentHarnessRuntime {
             .map(({ record }) => record);
         return { items };
     }
+    async listMemories(input = {}) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("listMemories requires a runtime entry binding.");
+        }
+        const workspaceId = this.getWorkspaceId(binding);
+        const scopes = Array.isArray(input.scopes) && input.scopes.length > 0
+            ? Array.from(new Set(input.scopes))
+            : ["thread", "agent", "workspace", "user", "project"];
+        const kinds = input.kinds?.length ? new Set(input.kinds) : null;
+        const statuses = input.status?.length ? new Set(input.status) : new Set(["active"]);
+        const limit = typeof input.limit === "number" && Number.isInteger(input.limit) && input.limit > 0
+            ? input.limit
+            : Number.POSITIVE_INFINITY;
+        const items = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, scopes))
+            .filter((record) => statuses.has(record.status))
+            .filter((record) => !kinds || kinds.has(record.kind))
+            .filter((record) => this.matchesMemoryFilters(record, {
+            threadId: input.threadId,
+            agentId: input.agentId,
+            workspaceId: input.workspaceId ?? workspaceId,
+            userId: input.userId,
+            projectId: input.projectId,
+        }))
+            .sort((left, right) => right.lastConfirmedAt.localeCompare(left.lastConfirmedAt))
+            .slice(0, limit);
+        return { items };
+    }
+    async updateMemory(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("updateMemory requires a runtime entry binding.");
+        }
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("updateMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.runtimeMemoryStore, input.memoryId.trim());
+        if (!existing) {
+            throw new Error(`Memory record not found: ${input.memoryId}`);
+        }
+        const updatedAt = new Date().toISOString();
+        const nextContent = typeof input.content === "string"
+            ? input.content.trim()
+            : existing.content;
+        if (nextContent.length === 0) {
+            throw new Error("updateMemory requires content to remain non-empty.");
+        }
+        const next = {
+            ...existing,
+            content: nextContent,
+            summary: typeof input.summary === "string"
+                ? input.summary.trim() || this.summarizeMemoryContent(nextContent)
+                : (typeof input.content === "string" ? this.summarizeMemoryContent(nextContent) : existing.summary),
+            status: input.status ?? existing.status,
+            confidence: typeof input.confidence === "number" ? Math.max(0, Math.min(1, input.confidence)) : existing.confidence,
+            expiresAt: input.expiresAt === undefined ? existing.expiresAt : (input.expiresAt ?? undefined),
+            sourceType: typeof input.sourceType === "string" && input.sourceType.trim().length > 0 ? input.sourceType.trim() : existing.sourceType,
+            sourceRefs: Array.isArray(input.sourceRefs)
+                ? Array.from(new Set(input.sourceRefs.map((item) => item.trim()).filter((item) => item.length > 0)))
+                : existing.sourceRefs,
+            tags: Array.isArray(input.tags)
+                ? Array.from(new Set(input.tags.map((item) => item.trim()).filter((item) => item.length > 0)))
+                : existing.tags,
+            observedAt: typeof input.observedAt === "string" && input.observedAt.trim().length > 0 ? input.observedAt : existing.observedAt,
+            lastConfirmedAt: typeof input.lastConfirmedAt === "string" && input.lastConfirmedAt.trim().length > 0
+                ? input.lastConfirmedAt
+                : updatedAt,
+            provenance: input.provenance ? { ...existing.provenance, ...input.provenance } : existing.provenance,
+            revision: existing.revision + 1,
+        };
+        await updateMemoryRecord(this.runtimeMemoryStore, next, updatedAt);
+        await this.rebuildRuntimeMemoryVectorIndex();
+        await this.refreshStructuredMemoryScope(binding, next);
+        return next;
+    }
+    async removeMemory(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("removeMemory requires a runtime entry binding.");
+        }
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("removeMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.runtimeMemoryStore, input.memoryId.trim());
+        if (!existing) {
+            throw new Error(`Memory record not found: ${input.memoryId}`);
+        }
+        await removeMemoryRecord(this.runtimeMemoryStore, existing.scope, existing.id);
+        await this.rebuildRuntimeMemoryVectorIndex();
+        await this.refreshStructuredMemoryScope(binding, existing);
+        return existing;
+    }
     async getRun(runId) {
         return this.persistence.getRun(runId);
     }
@@ -383,6 +475,51 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
         }, approvalId);
     }
+    async listArtifacts(threadId, runId) {
+        return this.persistence.listArtifacts(threadId, runId);
+    }
+    async readArtifact(threadId, runId, artifactPath) {
+        return this.persistence.readArtifact(threadId, runId, artifactPath);
+    }
+    async listRunEvents(threadId, runId) {
+        return this.persistence.listRunEvents(threadId, runId);
+    }
+    async exportEvaluationBundle(input) {
+        const thread = await this.getThread(input.sessionId);
+        const run = await this.getRun(input.requestId);
+        const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
+        const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
+        const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
+        const runtimeHealth = await this.getHealth();
+        const artifactsListing = input.includeArtifacts === false
+            ? { items: [] }
+            : await this.persistence.listArtifacts(input.sessionId, input.requestId);
+        const artifacts = await Promise.all(artifactsListing.items.map(async (artifact) => ({
+            ...artifact,
+            ...(input.includeArtifactContents === true
+                ? { content: await this.persistence.readArtifact(input.sessionId, input.requestId, artifact.path) }
+                : {}),
+        })));
+        return {
+            session: thread ? toSessionRecord(thread) : null,
+            request: run ? toRequestRecord(run) : null,
+            approvals,
+            transcript,
+            events,
+            artifacts,
+            runtimeHealth,
+            ...(typeof input.expectedOutput === "string" && input.expectedOutput.trim().length > 0
+                ? { expectedOutput: input.expectedOutput.trim() }
+                : {}),
+            rubric: Array.isArray(input.rubric)
+                ? input.rubric.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            tags: Array.isArray(input.tags)
+                ? input.tags.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            ...(input.metadata ? { metadata: { ...input.metadata } } : {}),
+        };
+    }
     listAgentSkills(agentId, options = {}) {
         return listWorkspaceAgentSkills(this.workspace, agentId, {
             assessRequirements: isInventoryEnabled(this.workspace),
@@ -514,7 +651,7 @@ export class AgentHarnessRuntime {
         const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
         return resolveMemoryNamespace(template, {
             threadId: options.threadId,
-            agentId: binding.agent.id,
+            agentId: options.agentId ?? binding.agent.id,
             workspaceId,
             userId: options.userId ?? "default",
             projectId: options.projectId ?? workspaceId,
@@ -524,6 +661,27 @@ export class AgentHarnessRuntime {
         const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
         return path.basename(workspaceRoot) || "default";
     }
+    summarizeMemoryContent(content) {
+        return (content.trim().split("\n")[0] || content.trim()).slice(0, 240);
+    }
+    matchesMemoryFilters(record, filters) {
+        if (filters.threadId && record.provenance.threadId !== filters.threadId) {
+            return false;
+        }
+        if (filters.agentId && record.provenance.agentId !== filters.agentId) {
+            return false;
+        }
+        if (filters.workspaceId && record.provenance.workspaceId !== filters.workspaceId) {
+            return false;
+        }
+        if (filters.userId && record.provenance.userId !== filters.userId) {
+            return false;
+        }
+        if (filters.projectId && record.provenance.projectId !== filters.projectId) {
+            return false;
+        }
+        return true;
+    }
     resolveRecallScopes(input) {
         if (Array.isArray(input.scopes) && input.scopes.length > 0) {
             return Array.from(new Set(input.scopes));
@@ -755,6 +913,30 @@ export class AgentHarnessRuntime {
             // Fail open: vector indexing must not break durable memory writes.
         }
     }
+    async refreshStructuredMemoryScope(binding, record) {
+        const provenance = record.provenance;
+        const maxEntries = record.scope === "thread" ? 12 : 20;
+        const titleByScope = {
+            thread: "Thread Structured Memory",
+            agent: "Agent Structured Memory",
+            workspace: "Workspace Structured Memory",
+            user: "User Structured Memory",
+            project: "Project Structured Memory",
+        };
+        await consolidateStructuredMemoryScope({
+            store: this.runtimeMemoryStore,
+            namespace: this.resolveMemoryNamespace(record.scope, binding, {
+                threadId: provenance.threadId,
+                agentId: provenance.agentId,
+                userId: provenance.userId,
+                projectId: provenance.projectId,
+            }),
+            title: titleByScope[record.scope],
+            scope: record.scope,
+            maxEntries,
+            config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+        });
+    }
     async buildRuntimeMemoryContext(binding, threadId, input) {
         const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
         const workspaceId = this.getWorkspaceId(binding);
@@ -1256,3 +1438,40 @@ export class AgentHarnessRuntime {
         }, thread, nowMs);
     }
 }
+function toRequestSummary(summary) {
+    return {
+        requestId: summary.runId,
+        sessionId: summary.threadId,
+        agentId: summary.agentId,
+        executionMode: summary.executionMode,
+        adapterKind: summary.adapterKind,
+        createdAt: summary.createdAt,
+        updatedAt: summary.updatedAt,
+        state: summary.state,
+        checkpointRef: summary.checkpointRef,
+        resumable: summary.resumable,
+        startedAt: summary.startedAt,
+        endedAt: summary.endedAt,
+        lastActivityAt: summary.lastActivityAt,
+        currentAgentId: summary.currentAgentId,
+        delegationChain: summary.delegationChain,
+        runtimeSnapshot: summary.runtimeSnapshot,
+    };
+}
+function toSessionRecord(record) {
+    return {
+        sessionId: record.threadId,
+        entryAgentId: record.entryAgentId,
+        currentAgentId: record.currentAgentId,
+        currentState: record.currentState,
+        latestRequestId: record.latestRunId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        messages: record.messages,
+        requests: record.runs.map(toRequestSummary),
+        pendingDecision: record.pendingDecision,
+    };
+}
+function toRequestRecord(record) {
+    return toRequestSummary(record);
+}

package/dist/workspace/agent-binding-compiler.js

@@ -337,6 +337,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
+    const runtimeFilesystemDefaults = agent.executionMode === "langchain-v1"
+        ? asObject(runtimeDefaults?.filesystem)
+        : undefined;
+    const compiledFilesystemConfig = agent.executionMode === "langchain-v1"
+        ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
+        : undefined;
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -362,7 +368,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                     langchain: {
                         passthrough,
                         interruptOn: resolveInterruptOn(agent),
-                        filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                        filesystem: compiledFilesystemConfig,
                         subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
                         memory: compiledAgentMemory,
                         skills: compiledAgentSkills,

package/dist/workspace/object-loader.js

@@ -6,7 +6,7 @@ import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
 import { isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath } from "../tool-modules.js";
 import { fileExists } from "../utils/fs.js";
-import { readNamedModelItems, readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
+import { readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
 export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
 const MODULE_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
@@ -39,16 +39,10 @@ function conventionalConfigRoot(root) {
 }
 function conventionalDirectoryRoots(root, relativeDir) {
     const resourceRoot = resolveResourcePackageRoot(root);
-    const configRoot = conventionalConfigRoot(root);
-    const candidates = relativeDir === "agents"
-        ? [
-            ...(configRoot ? [path.join(configRoot, "agents")] : []),
-            path.join(root, "agents"),
-        ]
-        : [
-            ...(resourceRoot ? [path.join(resourceRoot, relativeDir)] : []),
-            path.join(root, relativeDir),
-        ];
+    const candidates = [
+        ...(resourceRoot ? [path.join(resourceRoot, relativeDir)] : []),
+        path.join(root, relativeDir),
+    ];
     return Array.from(new Set(candidates));
 }
 export function conventionalPackageRoots(root, relativeDir) {
@@ -569,20 +563,6 @@ function mergeAgentRecord(records, item, sourcePath) {
 function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
     mergeRawItemRecord(records, `${workspaceObject.kind}/${workspaceObject.id}`, item, sourcePath);
 }
-async function loadNamedModelsForRoot(configRoot, mergedObjects) {
-    for (const { item, sourcePath } of await readNamedModelItems(configRoot)) {
-        const workspaceObject = parseWorkspaceObject(item, sourcePath);
-        if (!workspaceObject || workspaceObject.kind !== "model") {
-            continue;
-        }
-        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
-    }
-}
-async function loadConfigAgentsForRoot(configRoot, mergedAgents) {
-    for (const { item, sourcePath } of await readConfigAgentItems(configRoot)) {
-        mergeAgentRecord(mergedAgents, item, sourcePath);
-    }
-}
 async function loadModuleAgentsForRoot(root, mergedAgents) {
     const modulesRoot = moduleCollectionRoot(root, "agents");
     if (!(await fileExists(modulesRoot))) {
@@ -675,7 +655,7 @@ async function loadModuleObjectsForRoot(root, mergedObjects) {
         mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
     }
 }
-async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
+async function loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects) {
     if (!conventionalConfigRoot(root)) {
         return;
     }
@@ -684,7 +664,8 @@ async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
         if (!workspaceObject) {
             continue;
         }
-        if (isAgentKind(workspaceObject.kind) || workspaceObject.kind === "model") {
+        if (isAgentKind(workspaceObject.kind)) {
+            mergeAgentRecord(mergedAgents, item, sourcePath);
             continue;
         }
         mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
@@ -708,20 +689,6 @@ async function loadRootObjects(root, mergedObjects) {
 function isAgentKind(kind) {
     return kind === "agent";
 }
-async function readConfigAgentItems(configRoot) {
-    const records = await readYamlItems(configRoot, undefined, { recursive: true });
-    return records.filter(({ item, sourcePath }) => {
-        const kind = typeof item.kind === "string" ? item.kind : undefined;
-        if (!isAgentKind(kind)) {
-            return false;
-        }
-        const relativePath = path.relative(configRoot, sourcePath);
-        if (!relativePath || relativePath.startsWith("..")) {
-            return false;
-        }
-        return !relativePath.includes(path.sep) || relativePath.startsWith(`agents${path.sep}`);
-    });
-}
 export async function readToolModuleItems(root) {
     if (!(await fileExists(root))) {
         return [];
@@ -792,11 +759,9 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
     const roots = [frameworkWorkspaceRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
     for (const root of roots) {
         const configRoot = conventionalConfigRoot(root) ?? root;
-        await loadNamedModelsForRoot(configRoot, mergedObjects);
-        await loadConfigAgentsForRoot(configRoot, mergedAgents);
+        await loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects);
         await loadModuleAgentsForRoot(root, mergedAgents);
         await loadConventionalObjectsForRoot(root, mergedObjects);
-        await loadConfigObjectsForRoot(root, configRoot, mergedObjects);
         await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);
     }

package/dist/workspace/yaml-object-reader.d.ts

@@ -9,7 +9,3 @@ export declare function readNamedYamlItems(root: string, filenames: string[]): P
     item: Record<string, unknown>;
     sourcePath: string;
 }>>;
-export declare function readNamedModelItems(root: string): Promise<Array<{
-    item: Record<string, unknown>;
-    sourcePath: string;
-}>>;

package/dist/workspace/yaml-object-reader.js

@@ -2,7 +2,6 @@ import path from "node:path";
 import { readdir } from "node:fs/promises";
 import { parseAllDocuments } from "yaml";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
-const MODEL_FILENAMES = ["models.yaml", "models.yml"];
 const ENV_PLACEHOLDER_PATTERN = /\$\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
@@ -165,7 +164,10 @@ export async function readYamlItems(root, relativeDir, options = {}) {
         return [];
     }
     const files = options.recursive
-        ? await listFilesRecursive(targetRoot, ".yaml")
+        ? Array.from(new Set([
+            ...(await listFilesRecursive(targetRoot, ".yaml")),
+            ...(await listFilesRecursive(targetRoot, ".yml")),
+        ])).sort()
         : (await readdir(targetRoot, { withFileTypes: true }))
             .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
             .map((entry) => path.join(targetRoot, entry.name))
@@ -199,33 +201,3 @@ export async function readNamedYamlItems(root, filenames) {
     }
     return records;
 }
-export async function readNamedModelItems(root) {
-    const filePaths = new Set();
-    for (const filename of MODEL_FILENAMES) {
-        const directPath = path.join(root, filename);
-        if (await fileExists(directPath)) {
-            filePaths.add(directPath);
-        }
-    }
-    for (const extension of [".yaml", ".yml"]) {
-        for (const filePath of await listFilesRecursive(root, extension)) {
-            if (MODEL_FILENAMES.includes(path.basename(filePath))) {
-                filePaths.add(filePath);
-            }
-        }
-    }
-    const records = [];
-    for (const filePath of [...filePaths].sort()) {
-        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
-        for (const parsedDocument of parsedDocuments) {
-            const resolvedDocument = interpolateEnvPlaceholders(parsedDocument.toJSON(), filePath);
-            for (const item of await objectItemsFromDocument(resolvedDocument, filePath)) {
-                const normalized = normalizeYamlItem(item);
-                if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
-                    records.push({ item: normalized, sourcePath: filePath });
-                }
-            }
-        }
-    }
-    return records;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.155",
+  "version": "0.0.157",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -28,6 +28,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./acp": {
+      "types": "./dist/acp.d.ts",
+      "import": "./dist/acp.js",
+      "default": "./dist/acp.js"
+    },
     "./tools": {
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js",