macro-agent 0.2.5 → 0.2.6

package/src/dispatch/permission-overlay.ts

@@ -1,89 +0,0 @@
-/**
- * Permission Overlay Registry
- *
- * Process-singleton map of `agentId → Permissions` for in-flight
- * dispatches. The `PreToolUse` hook installed at spawn time consults
- * this registry on every tool call. Dispatch consumers (e.g., the
- * mail-inbound-reuse-consumer) set the overlay when claiming an
- * in-flight dispatch and clear it on resolution.
- *
- * Why a registry rather than a per-spawn argument:
- *   - The session is created with permissive rules at boot. The
- *     dispatch's narrower deny rules need to apply at *call time*, not
- *     at spawn time, because the agent already exists when the dispatch
- *     arrives. The hook closure captures `agentId` and reads the
- *     registry per-call so updates propagate without recreating the
- *     session.
- *
- * Semantics:
- *   - Intersection-only: the overlay can ADD denies to a session but
- *     cannot grant new allows. If the session was spawned with broad
- *     permissions and the overlay says `allow: [Read]`, the session's
- *     other tools still work — the overlay only tightens.
- *   - Single overlay per agent: `mail-inbound-reuse-consumer` already
- *     enforces one in-flight dispatch per agent (`recipient_busy`
- *     reject), so overwriting is safe.
- *
- * @module dispatch/permission-overlay
- */
-
-export interface OverlayPermissions {
-  allow?: string[];
-  deny?: string[];
-  ask?: string[];
-}
-
-const overlays = new Map<string, OverlayPermissions>();
-
-/**
- * Apply a permission overlay for an agent. Subsequent tool calls by
- * that agent flow through the `PreToolUse` hook, which consults this
- * registry. Overwrites any prior overlay for the same agent.
- */
-export function setPermissionOverlay(
-  agentId: string,
-  perms: OverlayPermissions,
-): void {
-  overlays.set(agentId, perms);
-}
-
-/**
- * Remove the active overlay for an agent. Subsequent tool calls fall
- * back to the session's static permission rules.
- */
-export function clearPermissionOverlay(agentId: string): void {
-  overlays.delete(agentId);
-}
-
-/**
- * Read the current overlay for an agent. Returns `undefined` when no
- * overlay is in effect — the hook treats that as pass-through.
- */
-export function getPermissionOverlay(
-  agentId: string,
-): OverlayPermissions | undefined {
-  return overlays.get(agentId);
-}
-
-/**
- * Clear all overlays. Used as defense-in-depth when a fresh consumer
- * starts (process startup); also exposed for test isolation.
- */
-export function clearAllPermissionOverlays(): void {
-  overlays.clear();
-}
-
-/**
- * Test helper — alias for `clearAllPermissionOverlays`. Kept distinct
- * so it's grep-able for "test-only" cleanup paths.
- */
-export function _resetForTest(): void {
-  overlays.clear();
-}
-
-/**
- * Test helper — number of overlays currently active.
- */
-export function _sizeForTest(): number {
-  return overlays.size;
-}

package/src/dispatch/permissions-handler.ts

@@ -1,112 +0,0 @@
-/**
- * `x-dispatch/permissions.set` and `x-dispatch/permissions.clear` MAP
- * notification handlers — runtime-agnostic wire shape, macro-agent-specific
- * implementation.
- *
- * Called by OpenHive's orchestrator on the ACP+reuse dispatch path to apply
- * per-dispatch loadout deny/allow rules to a long-lived agent's session at
- * runtime, without recreating the session. The handler invokes
- * `setPermissionOverlay` (resp. `clearPermissionOverlay`); the prompt
- * iterator in `agent-manager-v2.ts` enforces the overlay against
- * `permission_request` ACP session updates.
- *
- * See `docs/PERMISSION_OVERLAY_ACP_DESIGN.md` for the four-process flow
- * diagram and rationale. The mail+reuse path uses the same overlay
- * registry but sets/clears it directly from `mail-inbound-reuse-consumer`
- * (which has a clean entry point on swarm side); ACP+reuse needs this MAP
- * wire because the dispatch's prompt arrives through the ACP server with
- * no equivalent consumer to bracket.
- *
- * Wire shape (set):
- *
- *   request:  { agent_id: string, deny?: string[], allow?: string[] }
- *   response: { ok: true } | { ok: false, error: string }
- *
- * Wire shape (clear):
- *
- *   request:  { agent_id: string }
- *   response: { ok: true } | { ok: false, error: string }
- *
- * Notification-pair pattern matches the existing `x-dispatch/spawn-agent`
- * handler (the MAP SDK's AgentConnection doesn't expose
- * setRequestHandler, so we use notifications with correlation_ids).
- */
-
-import {
-  setPermissionOverlay,
-  clearPermissionOverlay,
-} from "./permission-overlay.js";
-
-export interface PermissionsSetRequest {
-  agent_id: string;
-  deny?: string[];
-  allow?: string[];
-}
-
-export interface PermissionsClearRequest {
-  agent_id: string;
-}
-
-export type PermissionsResponse =
-  | { ok: true }
-  | { ok: false; error: string };
-
-/**
- * Handle `x-dispatch/permissions.set.request`. Sets the per-agent overlay
- * registry entry that the prompt iterator consults when answering
- * `permission_request` session updates.
- *
- * Idempotent: re-setting on the same agent overwrites the prior overlay.
- * Safe: returns an error response (rather than throwing) for malformed
- * params or unknown agents — the orchestrator should log and proceed.
- */
-export function handlePermissionsSet(
-  params: PermissionsSetRequest,
-  log: (msg: string) => void = console.log,
-): PermissionsResponse {
-  if (!params || typeof params.agent_id !== "string" || params.agent_id === "") {
-    return { ok: false, error: "x-dispatch/permissions.set: missing or invalid 'agent_id'" };
-  }
-  if (params.deny !== undefined && !Array.isArray(params.deny)) {
-    return { ok: false, error: "x-dispatch/permissions.set: 'deny' must be an array of strings" };
-  }
-  if (params.allow !== undefined && !Array.isArray(params.allow)) {
-    return { ok: false, error: "x-dispatch/permissions.set: 'allow' must be an array of strings" };
-  }
-
-  const overlay = {
-    ...(params.deny ? { deny: params.deny } : {}),
-    ...(params.allow ? { allow: params.allow } : {}),
-  };
-  setPermissionOverlay(params.agent_id, overlay);
-  log(
-    `[x-dispatch/permissions.set] agent=${params.agent_id} ` +
-      `deny=${params.deny?.length ?? 0} allow=${params.allow?.length ?? 0}`,
-  );
-  return { ok: true };
-}
-
-/**
- * Handle `x-dispatch/permissions.clear.request`. Removes any overlay set
- * on the named agent. Idempotent: clearing a non-existent overlay is a
- * no-op success. Always paired with a prior `set` from the same dispatch;
- * the orchestrator must guarantee `clear` runs even on dispatch failure.
- */
-export function handlePermissionsClear(
-  params: PermissionsClearRequest,
-  log: (msg: string) => void = console.log,
-): PermissionsResponse {
-  if (!params || typeof params.agent_id !== "string" || params.agent_id === "") {
-    return { ok: false, error: "x-dispatch/permissions.clear: missing or invalid 'agent_id'" };
-  }
-  clearPermissionOverlay(params.agent_id);
-  log(`[x-dispatch/permissions.clear] agent=${params.agent_id}`);
-  return { ok: true };
-}
-
-export const X_DISPATCH_PERMISSIONS_METHODS = {
-  SET_REQUEST: "x-dispatch/permissions.set.request",
-  SET_RESPONSE: "x-dispatch/permissions.set.response",
-  CLEAR_REQUEST: "x-dispatch/permissions.clear.request",
-  CLEAR_RESPONSE: "x-dispatch/permissions.clear.response",
-} as const;

package/src/dispatch/spawn-agent-handler.ts

@@ -1,160 +0,0 @@
-/**
- * `x-dispatch/spawn-agent` MAP request handler — runtime-agnostic wire shape,
- * macro-agent-specific implementation.
- *
- * Called by OpenHive's orchestrator when ACP-routing a dispatch with
- * `lifecycle: 'fresh'` — the hub asks the swarm to spawn a fresh agent
- * with the materialized loadout's structured fields applied to its spawn
- * config. The handler returns the spawned agent's id; the orchestrator
- * then attaches an ACP stream via the existing `findAcpAgentInfo` path.
- *
- * Wire shape — canonical (swarm-dispatch's `RemoteSpawnRequest`):
- *
- *   request:
- *     {
- *       role: string,
- *       capabilities_required: string[],     // e.g. ["acp"]
- *       lifecycle: "fresh" | "reuse",
- *       cwd?: string,
- *       fullAutonomous?: boolean,
- *       consumer_extensions?: {
- *         openhive?: { loadout?: WireLoadout },   // OpenHive payload
- *       }
- *     }
- *
- *   response:
- *     { agentId: string }
- *
- * Legacy shape support: pre-Tier-2 callers passed `loadout` at the top
- * level (not under consumer_extensions). The handler accepts both for
- * one release window — `consumer_extensions.openhive.loadout` is read
- * first; falls back to top-level `loadout`.
- *
- * Symmetric with the mail path: both routes use `loadoutToSpawnOptions`
- * to translate the wire-level loadout into macro-agent's spawn options.
- */
-
-import type { AgentManager } from "../agent/agent-manager.js";
-import { loadoutToSpawnOptions, type WireLoadout } from "./loadout-translation.js";
-
-export interface SpawnAgentRequest {
-  role: string;
-  /** Optional cwd; defaults to the swarm's process.cwd() via agentManager. */
-  cwd?: string;
-  capabilities_required?: string[];
-  lifecycle?: "fresh" | "reuse";
-  /**
-   * @deprecated — pre-Tier-2 top-level loadout slot. Newer callers ship
-   * the loadout under `consumer_extensions.openhive.loadout`. Both
-   * shapes are accepted for one release window.
-   */
-  loadout?: WireLoadout;
-  /** Canonical consumer-extension namespace (Tier 2+). */
-  consumer_extensions?: {
-    openhive?: { loadout?: WireLoadout };
-    [otherConsumer: string]: unknown;
-  };
-  fullAutonomous?: boolean;
-  /** Optional initial task description; defaults to a placeholder so the
-   *  agent's session has *something* to render until the orchestrator's
-   *  ACP `session/prompt` arrives. */
-  task?: string;
-}
-
-export interface SpawnAgentResponse {
-  agentId: string;
-}
-
-export interface SpawnAgentHandlerDeps {
-  agentManager: AgentManager;
-  /**
-   * Optional barrier called after spawn so the spawned agent's
-   * lifecycle-bridge has had time to register its `protocols: ['acp']`
-   * capability with the hub before this handler returns. Without this
-   * the orchestrator's subsequent `findAcpAgentInfo` would race the
-   * registration and return null.
-   *
-   * Returns true once the agent is registered and ACP-capable; false on
-   * timeout. Implementations typically wait on a Promise resolved by
-   * the lifecycle-bridge's `agent.registered` callback.
-   */
-  waitForAcpRegistration?: (
-    agentId: string,
-    timeoutMs?: number,
-  ) => Promise<boolean>;
-  /** Optional logger; defaults to console.log. */
-  log?: (msg: string) => void;
-}
-
-const DEFAULT_REGISTRATION_TIMEOUT_MS = 5_000;
-
-export async function handleDispatchSpawnAgent(
-  params: SpawnAgentRequest,
-  deps: SpawnAgentHandlerDeps,
-): Promise<SpawnAgentResponse> {
-  const { agentManager, waitForAcpRegistration, log = console.log } = deps;
-
-  if (!params.role) {
-    throw new Error("x-dispatch/spawn-agent: missing 'role'");
-  }
-  if (params.lifecycle && params.lifecycle !== "fresh") {
-    throw new Error(
-      `x-dispatch/spawn-agent: lifecycle='${params.lifecycle}' not supported by this handler — ` +
-        `'reuse' is handled hub-side via findAcpAgentInfo, not via this method`,
-    );
-  }
-  // cwd is optional — agentManager.spawn defaults to its own defaultCwd
-  // (typically process.cwd() of the macro-agent process) when omitted.
-
-  // Loadout location: prefer the canonical consumer_extensions.openhive
-  // slot (Tier 2+); fall back to the top-level field (pre-Tier-2). Older
-  // hubs ship the loadout at the top level; newer hubs ship under
-  // consumer_extensions. Both work during the dual-listen window.
-  const loadout: WireLoadout | undefined =
-    params.consumer_extensions?.openhive?.loadout ?? params.loadout;
-
-  const fullAutonomous = params.fullAutonomous ?? true;
-  const spawnLoadoutOpts = loadoutToSpawnOptions(loadout, {
-    fullAutonomous,
-  });
-
-  log(
-    `[x-dispatch/spawn-agent] Spawning fresh ${params.role} cwd=${params.cwd} ` +
-      `permissions=${
-        spawnLoadoutOpts.permissions ? JSON.stringify(spawnLoadoutOpts.permissions) : "(none)"
-      } fullAutonomous=${fullAutonomous}`,
-  );
-
-  const spawned = await agentManager.spawn({
-    role: params.role,
-    ...(params.cwd ? { cwd: params.cwd } : {}),
-    parent: null,
-    // Mail-inbound and dispatch-spawned coordinators alike run under
-    // isolated settings so host-level Claude plugins don't auto-mount.
-    isolatedSettings: true,
-    task:
-      params.task ?? "Awaiting dispatch (created by dispatch/spawn-agent)",
-    ...spawnLoadoutOpts,
-  });
-
-  // Block until the lifecycle-bridge has registered ACP capabilities,
-  // otherwise the orchestrator's subsequent `findAcpAgentInfo` lookup
-  // races the registration and fails. Best-effort: a timeout returns
-  // anyway and the orchestrator will retry on its own poll.
-  if (waitForAcpRegistration) {
-    const ok = await waitForAcpRegistration(
-      spawned.id,
-      DEFAULT_REGISTRATION_TIMEOUT_MS,
-    ).catch(() => false);
-    if (!ok) {
-      log(
-        `[x-dispatch/spawn-agent] Warning: ACP registration not confirmed for ` +
-          `agent ${spawned.id} within ${DEFAULT_REGISTRATION_TIMEOUT_MS}ms; ` +
-          `orchestrator may need to retry.`,
-      );
-    }
-  }
-
-  log(`[x-dispatch/spawn-agent] Spawn complete agentId=${spawned.id}`);
-  return { agentId: spawned.id };
-}

package/src/index.ts

@@ -1,117 +0,0 @@
-/**
- * macro-agent - Multi-agent orchestration system (V2)
- */
-
-// Store types (primitives used everywhere)
-export {
-  type Agent,
-  type AgentState,
-  type StopReason,
-  type AgentConfig,
-  type Task,
-  type TaskStatus,
-  type TaskAction,
-  type ArtifactRef,
-  type AgentHistoryEntry,
-  type Event,
-  type EventInput,
-  type EventFilter,
-  type EventType,
-  type EventSource,
-  type EventTarget,
-  type EventMetadata,
-  type AgentId,
-  type TaskId,
-  type EventId,
-  type SessionId,
-  type Timestamp,
-  type QueuedMessage,
-  type Subscription,
-  type SubscriptionType,
-  CURRENT_EVENT_VERSION,
-} from './store/types/index.js';
-
-// Agent manager (interface + V2 factory)
-export {
-  createAgentManager,
-  createAgentManagerV2,
-  type AgentManager,
-  type AgentManagerConfig,
-  type SpawnInterceptor,
-} from './agent/agent-manager.js';
-
-export {
-  type SpawnAgentOptions,
-  type SpawnedAgent,
-  type AgentFilter,
-  type AgentHierarchy,
-  type AgentHierarchyNode,
-  type ActiveSession,
-  type AgentStopReason,
-  type HeadManagerOptions,
-  type SystemPromptContext,
-  type AgentLifecycleEvent,
-  type AgentLifecycleCallback,
-  AgentManagerError,
-  type AgentManagerErrorCode,
-  type MCPServerConfig as AgentMCPServerConfig,
-  type MCPServerStdioConfig as AgentMCPServerStdioConfig,
-  type MCPServerHttpConfig as AgentMCPServerHttpConfig,
-  type AgentConfig as SpawnAgentConfig,
-} from './agent/types.js';
-
-export { generateSystemPrompt } from './agent/system-prompt.js';
-
-// Agent store (V2 lifecycle state)
-export { AgentStore } from './agent/agent-store.js';
-
-// Adapters (V2 messaging + tasks)
-export {
-  DefaultInboxAdapter,
-} from './adapters/inbox-adapter.js';
-
-export {
-  DefaultTasksAdapter,
-} from './adapters/tasks-adapter.js';
-
-export {
-  type InboxAdapter,
-  type TasksAdapter,
-} from './adapters/types.js';
-
-// Boot V2
-export {
-  bootV2,
-  type BootV2Config,
-  type MacroAgentSystemV2,
-} from './boot-v2.js';
-
-// Roles
-export {
-  type RoleDefinition,
-  type RoleRegistry,
-  type Capability,
-} from './roles/types.js';
-
-export { DefaultRoleRegistry } from './roles/registry.js';
-export { AGENT_CAPABILITIES } from './roles/capabilities.js';
-
-// Workspace
-export {
-  type WorkspaceManager,
-  type Workspace,
-} from './workspace/types.js';
-
-// Teams - template seeding
-export { seedDefaultTemplates } from './teams/seed-defaults.js';
-
-// MAP (sidecar + server)
-export { createMAPSidecar, createMAPServerInstance } from './map/index.js';
-export type {
-  MAPSidecar,
-  MAPSidecarConfig,
-  MAPServerInstance,
-  MapServerConfig,
-  TrajectoryCheckpointPayload,
-  TrajectoryCheckpointResult,
-} from './map/types.js';

package/src/integrations/__tests__/context-builder.test.ts

@@ -1,218 +0,0 @@
-/**
- * Unit Tests for Capabilities Context Builder
- *
- * Tests `buildCapabilitiesContext()` which generates markdown describing
- * available swarmkit integrations for injection into agent system prompts.
- *
- * Run:
- *   npx vitest run src/integrations/__tests__/context-builder.test.ts
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  buildCapabilitiesContext,
-  type CapabilitiesConfig,
-} from "../context-builder.js";
-
-describe("buildCapabilitiesContext", () => {
-  it("returns non-empty string with default sections even when no integrations enabled", () => {
-    const result = buildCapabilitiesContext({});
-
-    // Should still include the base sections (Task Management, Communication)
-    expect(result).toContain("## Swarm Capabilities");
-    expect(result).toContain("### Task Management");
-    expect(result).toContain("### Communication");
-  });
-
-  it("does not include memory section when minimem disabled", () => {
-    const result = buildCapabilitiesContext({
-      minimem: { enabled: false },
-    });
-
-    expect(result).not.toContain("### Memory");
-    expect(result).not.toContain("minimem");
-  });
-
-  it("includes memory section when minimem enabled", () => {
-    const result = buildCapabilitiesContext({
-      minimem: { enabled: true, status: "ready" },
-    });
-
-    expect(result).toContain("### Memory");
-    expect(result).toContain("minimem MCP tools");
-    expect(result).toContain("minimem__memory_search");
-    expect(result).toContain("minimem__memory_get_details");
-    expect(result).toContain("minimem__knowledge_search");
-    expect(result).toContain("team-wide");
-  });
-
-  it("includes opentasks section when opentasks connected", () => {
-    const result = buildCapabilitiesContext({
-      opentasks: { enabled: true, status: "connected" },
-    });
-
-    expect(result).toContain("opentasks MCP tools");
-    expect(result).toContain("opentasks__create_task");
-    expect(result).toContain("opentasks__update_task");
-    expect(result).toContain("opentasks__list_tasks");
-  });
-
-  it("does not include opentasks section when opentasks disabled", () => {
-    const result = buildCapabilitiesContext({
-      opentasks: { enabled: false },
-    });
-
-    expect(result).not.toContain("opentasks MCP tools");
-    expect(result).not.toContain("opentasks__create_task");
-  });
-
-  it("includes inbox section when inbox enabled", () => {
-    const result = buildCapabilitiesContext({
-      inbox: { enabled: true },
-    });
-
-    expect(result).toContain("agent-inbox MCP tools");
-    expect(result).toContain("agent-inbox__check_inbox");
-    expect(result).toContain("agent-inbox__send_message");
-    expect(result).toContain("agent-inbox__read_thread");
-    expect(result).toContain("agent-inbox__list_agents");
-  });
-
-  it("does not include inbox section when inbox disabled", () => {
-    const result = buildCapabilitiesContext({
-      inbox: { enabled: false },
-    });
-
-    expect(result).not.toContain("agent-inbox MCP tools");
-  });
-
-  it("includes MAP observability section when map enabled", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true, status: "connected" },
-      sessionlog: { enabled: true, sync: "metrics" },
-    });
-
-    expect(result).toContain("### External Observability");
-    expect(result).toContain("MAP: connected");
-    expect(result).toContain("trajectory checkpoints synced to MAP");
-  });
-
-  it("includes MAP scope in output", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true, scope: "swarm:worker-1" },
-    });
-
-    expect(result).toContain("scope: swarm:worker-1");
-  });
-
-  it("uses default scope when map.scope not provided", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true },
-    });
-
-    expect(result).toContain("scope: default");
-  });
-
-  it("shows no observability when map disabled", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: false },
-    });
-
-    expect(result).toContain("No external observability configured");
-    expect(result).not.toContain("MAP: connected");
-  });
-
-  it("includes skills section when skilltree enabled", () => {
-    const result = buildCapabilitiesContext({
-      skilltree: { enabled: true, status: "ready" },
-    });
-
-    expect(result).toContain("### Per-Role Skills");
-    expect(result).toContain("skill loadout");
-  });
-
-  it("does not include skills section when skilltree disabled", () => {
-    const result = buildCapabilitiesContext({
-      skilltree: { enabled: false },
-    });
-
-    expect(result).not.toContain("### Skills");
-  });
-
-  it("includes sessionlog info in MAP section when both enabled", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true },
-      sessionlog: { enabled: true, sync: "metrics" },
-    });
-
-    expect(result).toContain("### External Observability");
-    expect(result).toContain("level: metrics");
-  });
-
-  it("shows custom sync level for sessionlog", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    expect(result).toContain("level: full");
-  });
-
-  it("does not mention sessionlog when sessionlog disabled and map enabled", () => {
-    const result = buildCapabilitiesContext({
-      map: { enabled: true },
-      sessionlog: { enabled: false },
-    });
-
-    expect(result).toContain("### External Observability");
-    expect(result).not.toContain("level:");
-  });
-
-  it("combines all sections correctly when everything enabled", () => {
-    const config: CapabilitiesConfig = {
-      minimem: { enabled: true, status: "ready" },
-      skilltree: { enabled: true, status: "ready" },
-      sessionlog: { enabled: true, sync: "full" },
-      mesh: { enabled: true },
-      map: { enabled: true, scope: "swarm:test", status: "connected" },
-      opentasks: { enabled: true, status: "connected" },
-      inbox: { enabled: true },
-    };
-
-    const result = buildCapabilitiesContext(config);
-
-    // All sections present
-    expect(result).toContain("## Swarm Capabilities");
-    expect(result).toContain("### Team Orchestration");
-    expect(result).toContain("### Task Management");
-    expect(result).toContain("### Communication");
-    expect(result).toContain("### Memory");
-    expect(result).toContain("### Per-Role Skills");
-    expect(result).toContain("### External Observability");
-    expect(result).toContain("opentasks MCP tools");
-    expect(result).toContain("agent-inbox MCP tools");
-    expect(result).toContain("minimem MCP tools");
-    expect(result).toContain("swarm:test");
-    expect(result).toContain("level: full");
-
-    // Verify ordering: Task Management before Memory before Skills before Observability
-    const taskIdx = result.indexOf("### Task Management");
-    const commIdx = result.indexOf("### Communication");
-    const memIdx = result.indexOf("### Memory");
-    const skillIdx = result.indexOf("### Per-Role Skills");
-    const obsIdx = result.indexOf("### External Observability");
-
-    expect(taskIdx).toBeLessThan(commIdx);
-    expect(commIdx).toBeLessThan(memIdx);
-    expect(memIdx).toBeLessThan(skillIdx);
-    expect(skillIdx).toBeLessThan(obsIdx);
-  });
-
-  it("starts with the capabilities header", () => {
-    const result = buildCapabilitiesContext({
-      minimem: { enabled: true },
-    });
-
-    expect(result.startsWith("## Swarm Capabilities")).toBe(true);
-  });
-});