@soleri/core 9.0.4 → 9.3.0

package/src/runtime/sync-ops.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createSyncOps } from './sync-ops.js';
+import type { AgentRuntime } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+vi.mock('../vault/git-vault-sync.js', () => ({
+  GitVaultSync: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.init = vi.fn().mockResolvedValue(undefined);
+    this.syncAll = vi.fn().mockResolvedValue({ pushed: 5 });
+    this.pull = vi.fn().mockResolvedValue({ imported: 3, conflicts: 0 });
+    this.sync = vi.fn().mockResolvedValue({ pushed: 2, pulled: 1 });
+  }),
+}));
+
+vi.mock('../vault/linking.js', () => ({
+  LinkManager: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.getAllLinksForEntries = vi.fn().mockReturnValue([]);
+    this.addLink = vi.fn();
+  }),
+}));
+
+vi.mock('../vault/obsidian-sync.js', () => ({
+  ObsidianSync: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.export = vi.fn().mockResolvedValue({ exported: 10 });
+    this.import = vi.fn().mockResolvedValue({ imported: 5 });
+    this.sync = vi.fn().mockResolvedValue({ pushed: 3, pulled: 2 });
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock runtime
+// ---------------------------------------------------------------------------
+
+function mockRuntime(): AgentRuntime {
+  return {
+    config: { agentId: 'test-agent' },
+    vault: {
+      get: vi.fn(),
+      seed: vi.fn(),
+      seedDedup: vi.fn().mockReturnValue([]),
+      list: vi.fn().mockReturnValue([]),
+      exportAll: vi.fn().mockReturnValue({ entries: [] }),
+      getProvider: vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([]),
+        get: vi.fn(),
+        run: vi.fn(),
+      }),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: ReturnType<typeof createSyncOps>, name: string) {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op "${name}" not found`);
+  return op;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('createSyncOps', () => {
+  let rt: AgentRuntime;
+  let ops: ReturnType<typeof createSyncOps>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    rt = mockRuntime();
+    ops = createSyncOps(rt);
+  });
+
+  it('returns 8 ops', () => {
+    expect(ops.length).toBe(8);
+  });
+
+  it('has the expected op names', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'vault_git_push',
+      'vault_git_pull',
+      'vault_git_sync',
+      'obsidian_export',
+      'obsidian_import',
+      'obsidian_sync',
+      'vault_export_pack',
+      'vault_import_pack',
+    ]);
+  });
+
+  // ─── vault_git_push ───────────────────────────────────────────
+
+  describe('vault_git_push', () => {
+    it('initializes sync and pushes entries', async () => {
+      const op = findOp(ops, 'vault_git_push');
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
+      expect(result.pushed).toBe(5);
+    });
+  });
+
+  // ─── vault_git_pull ───────────────────────────────────────────
+
+  describe('vault_git_pull', () => {
+    it('pulls entries from git directory', async () => {
+      const op = findOp(ops, 'vault_git_pull');
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
+      expect(result.imported).toBe(3);
+    });
+  });
+
+  // ─── vault_git_sync ───────────────────────────────────────────
+
+  describe('vault_git_sync', () => {
+    it('performs bidirectional sync', async () => {
+      const op = findOp(ops, 'vault_git_sync');
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
+      expect(result.pushed).toBe(2);
+      expect(result.pulled).toBe(1);
+    });
+  });
+
+  // ─── obsidian_export ──────────────────────────────────────────
+
+  describe('obsidian_export', () => {
+    it('exports entries to Obsidian format', async () => {
+      const op = findOp(ops, 'obsidian_export');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.exported).toBe(10);
+    });
+  });
+
+  // ─── obsidian_import ──────────────────────────────────────────
+
+  describe('obsidian_import', () => {
+    it('imports from Obsidian directory', async () => {
+      const op = findOp(ops, 'obsidian_import');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.imported).toBe(5);
+    });
+  });
+
+  // ─── obsidian_sync ────────────────────────────────────────────
+
+  describe('obsidian_sync', () => {
+    it('performs bidirectional Obsidian sync', async () => {
+      const op = findOp(ops, 'obsidian_sync');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.pushed).toBe(3);
+      expect(result.pulled).toBe(2);
+    });
+  });
+
+  // ─── vault_export_pack ────────────────────────────────────────
+
+  describe('vault_export_pack', () => {
+    it('exports entries as intelligence bundles', async () => {
+      const op = findOp(ops, 'vault_export_pack');
+      vi.mocked(rt.vault.list).mockReturnValue([
+        { id: 'e1', domain: 'testing', tier: 'team', tags: [] },
+        { id: 'e2', domain: 'testing', tier: 'team', tags: [] },
+      ] as never);
+      const result = (await op.handler({ tier: 'team' })) as Record<string, unknown>;
+      expect(result.totalEntries).toBe(2);
+      expect(result.name).toBe('test-agent');
+    });
+
+    it('excludes specified IDs', async () => {
+      const op = findOp(ops, 'vault_export_pack');
+      vi.mocked(rt.vault.list).mockReturnValue([
+        { id: 'e1', domain: 'd', tier: 'team', tags: [] },
+        { id: 'e2', domain: 'd', tier: 'team', tags: [] },
+      ] as never);
+      const result = (await op.handler({ excludeIds: ['e1'] })) as Record<string, unknown>;
+      expect(result.totalEntries).toBe(1);
+    });
+  });
+
+  // ─── vault_import_pack ────────────────────────────────────────
+
+  describe('vault_import_pack', () => {
+    it('imports bundles and returns counts', async () => {
+      const op = findOp(ops, 'vault_import_pack');
+      vi.mocked(rt.vault.seedDedup).mockReturnValue([
+        { id: 'new-1', action: 'inserted' },
+        { id: 'dup-1', action: 'skipped', existingId: 'existing-1' },
+      ] as never);
+      const result = (await op.handler({
+        bundles: [
+          {
+            domain: 'testing',
+            version: '1.0.0',
+            entries: [{ id: 'e1' }, { id: 'e2' }],
+          },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.imported).toBe(1);
+      expect(result.duplicates).toBe(1);
+      expect(result.total).toBe(2);
+    });
+  });
+});

package/src/runtime/sync-ops.ts

@@ -0,0 +1,325 @@
+/**
+ * Sync Ops — git, Obsidian, and pack sync operations.
+ *
+ * Covers:
+ * - #67: Vault push/pull git sync with conflict resolution
+ * - Obsidian bidirectional sync
+ * - #104: Vault export/import shareable packs
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+import { GitVaultSync, type GitVaultSyncConfig } from '../vault/git-vault-sync.js';
+import type {
+  IntelligenceEntry,
+  IntelligenceBundle,
+  IntelligenceBundleLink,
+} from '../intelligence/types.js';
+import { LinkManager } from '../vault/linking.js';
+import { ObsidianSync } from '../vault/obsidian-sync.js';
+
+export function createSyncOps(runtime: AgentRuntime): OpDefinition[] {
+  const { vault } = runtime;
+
+  return [
+    // ─── Git Sync (#67) ───────────────────────────────────────────
+    {
+      name: 'vault_git_push',
+      description:
+        'Push all vault entries to a git-tracked directory. Each entry becomes a JSON file under domain subdirectories.',
+      auth: 'write' as const,
+      schema: z.object({
+        repoDir: z.string().describe('Path to git-tracked vault directory'),
+        authorName: z.string().optional().describe('Git author name'),
+        authorEmail: z.string().optional().describe('Git author email'),
+      }),
+      handler: async (params) => {
+        const config: GitVaultSyncConfig = {
+          repoDir: params.repoDir as string,
+          authorName: params.authorName as string | undefined,
+          authorEmail: params.authorEmail as string | undefined,
+        };
+        const sync = new GitVaultSync(config);
+        await sync.init();
+        const { entries } = vault.exportAll();
+        return sync.syncAll(entries);
+      },
+    },
+    {
+      name: 'vault_git_pull',
+      description:
+        'Pull entries from a git-tracked directory into the vault. Reads JSON files and imports with conflict resolution.',
+      auth: 'write' as const,
+      schema: z.object({
+        repoDir: z.string().describe('Path to git-tracked vault directory'),
+        onConflict: z
+          .enum(['git', 'vault'])
+          .optional()
+          .describe(
+            'Conflict resolution: "git" (default) overwrites vault, "vault" keeps existing',
+          ),
+      }),
+      handler: async (params) => {
+        const config: GitVaultSyncConfig = {
+          repoDir: params.repoDir as string,
+          autoCommit: false,
+        };
+        const sync = new GitVaultSync(config);
+        await sync.init();
+        return sync.pull(vault, {
+          onConflict: params.onConflict as 'git' | 'vault' | undefined,
+        });
+      },
+    },
+    {
+      name: 'vault_git_sync',
+      description:
+        'Bidirectional sync between vault and git directory. Pushes vault entries to git and pulls git-only entries into vault.',
+      auth: 'write' as const,
+      schema: z.object({
+        repoDir: z.string().describe('Path to git-tracked vault directory'),
+        onConflict: z
+          .enum(['git', 'vault'])
+          .optional()
+          .describe('Conflict resolution for entries that exist in both'),
+        authorName: z.string().optional(),
+        authorEmail: z.string().optional(),
+      }),
+      handler: async (params) => {
+        const config: GitVaultSyncConfig = {
+          repoDir: params.repoDir as string,
+          authorName: params.authorName as string | undefined,
+          authorEmail: params.authorEmail as string | undefined,
+        };
+        const sync = new GitVaultSync(config);
+        await sync.init();
+        return sync.sync(vault, {
+          onConflict: params.onConflict as 'git' | 'vault' | undefined,
+        });
+      },
+    },
+
+    // ─── Obsidian Sync ──────────────────────────────────────────
+    {
+      name: 'obsidian_export',
+      description:
+        'Export vault entries to Obsidian-compatible markdown files with YAML frontmatter. Creates domain subdirectories.',
+      auth: 'read' as const,
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
+        types: z.array(z.string()).optional().describe('Filter by entry types'),
+        domains: z.array(z.string()).optional().describe('Filter by domains'),
+        dryRun: z.boolean().optional().describe('Preview without writing files'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.export(params.obsidianDir as string, {
+          types: params.types as string[] | undefined,
+          domains: params.domains as string[] | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+    {
+      name: 'obsidian_import',
+      description:
+        'Import Obsidian markdown files with YAML frontmatter into the vault. Parses title, type, domain, tags from frontmatter.',
+      auth: 'write' as const,
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory to import from'),
+        defaultType: z
+          .string()
+          .optional()
+          .describe('Default type for entries without frontmatter type'),
+        defaultDomain: z.string().optional().describe('Default domain for entries without one'),
+        dryRun: z.boolean().optional().describe('Preview without modifying vault'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.import(params.obsidianDir as string, {
+          defaultType: params.defaultType as string | undefined,
+          defaultDomain: params.defaultDomain as string | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+    {
+      name: 'obsidian_sync',
+      description:
+        'Bidirectional sync between vault and Obsidian directory. Modes: push (vault→Obsidian), pull (Obsidian→vault), bidirectional.',
+      auth: 'write' as const,
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
+        mode: z
+          .enum(['push', 'pull', 'bidirectional'])
+          .optional()
+          .describe('Sync mode. Default: bidirectional'),
+        dryRun: z.boolean().optional().describe('Preview without making changes'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.sync(params.obsidianDir as string, {
+          mode: params.mode as 'push' | 'pull' | 'bidirectional' | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+
+    // ─── Export to Pack (#104) ─────────────────────────────────────
+    {
+      name: 'vault_export_pack',
+      description:
+        'Export vault entries as a shareable intelligence pack. Filters by tier, domain, or tags. Returns IntelligenceBundle format.',
+      auth: 'read' as const,
+      schema: z.object({
+        name: z.string().optional().describe('Pack name (default: agent ID)'),
+        version: z.string().optional().describe('Pack version (default: 1.0.0)'),
+        tier: z.enum(['agent', 'project', 'team']).optional().describe('Filter by scope tier'),
+        domain: z.string().optional().describe('Filter by domain'),
+        tags: z.array(z.string()).optional().describe('Filter by tags (OR match)'),
+        excludeIds: z.array(z.string()).optional().describe('Entry IDs to exclude'),
+      }),
+      handler: async (params) => {
+        const tier = params.tier as string | undefined;
+        const domain = params.domain as string | undefined;
+        const tags = params.tags as string[] | undefined;
+        const excludeIds = new Set((params.excludeIds as string[] | undefined) ?? []);
+
+        // Get all matching entries
+        let entries = vault.list({ domain, tags, limit: 10000 });
+
+        // Filter by tier if specified
+        if (tier) {
+          entries = entries.filter((e) => e.tier === tier);
+        }
+
+        // Exclude specified IDs
+        if (excludeIds.size > 0) {
+          entries = entries.filter((e) => !excludeIds.has(e.id));
+        }
+
+        // Group by domain into bundles
+        const byDomain = new Map<string, IntelligenceEntry[]>();
+        for (const entry of entries) {
+          const d = entry.domain;
+          if (!byDomain.has(d)) byDomain.set(d, []);
+          byDomain.get(d)!.push(entry);
+        }
+
+        // Collect links for exported entries (Zettelkasten edge export)
+        const entryIds = new Set(entries.map((e) => e.id));
+        const linkManager = new LinkManager(vault.getProvider());
+        const allLinks = linkManager.getAllLinksForEntries([...entryIds]);
+        // Only include links where BOTH endpoints are in the export set
+        const exportLinks = allLinks.filter(
+          (l) => entryIds.has(l.sourceId) && entryIds.has(l.targetId),
+        );
+
+        // Build a domain→links map (group by source entry's domain)
+        const entryDomainMap = new Map(entries.map((e) => [e.id, e.domain]));
+        const linksByDomain = new Map<string, IntelligenceBundleLink[]>();
+        for (const link of exportLinks) {
+          const linkDomain = entryDomainMap.get(link.sourceId) ?? 'unknown';
+          if (!linksByDomain.has(linkDomain)) linksByDomain.set(linkDomain, []);
+          linksByDomain.get(linkDomain)!.push({
+            sourceId: link.sourceId,
+            targetId: link.targetId,
+            linkType: link.linkType,
+            note: link.note,
+          });
+        }
+
+        const version = (params.version as string) ?? '1.0.0';
+        const bundles: IntelligenceBundle[] = [];
+        for (const [d, domainEntries] of byDomain) {
+          bundles.push({
+            domain: d,
+            version,
+            entries: domainEntries,
+            links: linksByDomain.get(d) ?? [],
+          });
+        }
+
+        return {
+          name: (params.name as string) ?? runtime.config.agentId,
+          version,
+          bundles,
+          totalEntries: entries.length,
+          totalLinks: exportLinks.length,
+          domains: [...byDomain.keys()],
+        };
+      },
+    },
+    {
+      name: 'vault_import_pack',
+      description:
+        'Import an intelligence pack into the vault with content-hash dedup. Entries with duplicate content are skipped.',
+      auth: 'write' as const,
+      schema: z.object({
+        bundles: z
+          .array(
+            z.object({
+              domain: z.string(),
+              version: z.string(),
+              entries: z.array(z.record(z.unknown())),
+            }),
+          )
+          .describe('Array of IntelligenceBundle objects to import'),
+        tier: z
+          .enum(['agent', 'project', 'team'])
+          .optional()
+          .describe('Force all imported entries to this tier'),
+      }),
+      handler: async (params) => {
+        const bundles = params.bundles as Array<{
+          domain: string;
+          version: string;
+          entries: IntelligenceEntry[];
+          links?: IntelligenceBundleLink[];
+        }>;
+        const forceTier = params.tier as 'agent' | 'project' | 'team' | undefined;
+        let imported = 0;
+        let duplicates = 0;
+        let linksCreated = 0;
+        let linksSkipped = 0;
+
+        // Track ID remapping: bundle entry ID → actual vault entry ID
+        const idRemap = new Map<string, string>();
+        const linkManager = new LinkManager(vault.getProvider());
+
+        for (const bundle of bundles) {
+          const entries = bundle.entries.map((e) => ({
+            ...e,
+            tier: forceTier ?? e.tier ?? 'project',
+          }));
+          const results = vault.seedDedup(entries);
+          for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const originalId = bundle.entries[i].id;
+            // For duplicates, map to the existing vault entry; for inserts, keep original ID
+            idRemap.set(originalId, r.existingId ?? r.id);
+            if (r.action === 'inserted') imported++;
+            else duplicates++;
+          }
+
+          // Import links if present
+          if (bundle.links && bundle.links.length > 0) {
+            for (const link of bundle.links) {
+              const sourceId = idRemap.get(link.sourceId);
+              const targetId = idRemap.get(link.targetId);
+              if (sourceId && targetId) {
+                linkManager.addLink(sourceId, targetId, link.linkType, link.note);
+                linksCreated++;
+              } else {
+                linksSkipped++;
+              }
+            }
+          }
+        }
+
+        return { imported, duplicates, linksCreated, linksSkipped, total: imported + duplicates };
+      },
+    },
+  ];
+}

package/src/runtime/telemetry-ops.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Unit tests for telemetry-ops — 2 ops: telemetry_errors, telemetry_slow_ops.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createTelemetryOps } from './telemetry-ops.js';
+import type { AgentRuntime } from './types.js';
+
+function makeTelemetryStub(
+  stats: {
+    errorsByOp: Record<string, number>;
+    slowestOps: Array<{ op: string; avgMs: number }>;
+    avgDurationMs: number;
+  },
+  recent: Array<{
+    op: string;
+    facade: string;
+    success: boolean;
+    error?: string;
+    timestamp: number;
+  }>,
+) {
+  return {
+    getStats: () => stats,
+    getRecent: (_limit: number) => recent,
+  };
+}
+
+describe('telemetry-ops', () => {
+  describe('telemetry_errors', () => {
+    it('returns empty when no errors', async () => {
+      const telemetry = makeTelemetryStub(
+        { errorsByOp: {}, slowestOps: [], avgDurationMs: 10 },
+        [],
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_errors');
+
+      expect(res.success).toBe(true);
+      const data = res.data as {
+        errorCount: number;
+        errorsByOp: Record<string, number>;
+        recentErrors: unknown[];
+      };
+      expect(data.errorCount).toBe(0);
+      expect(data.recentErrors).toEqual([]);
+      expect(data.errorsByOp).toEqual({});
+    });
+
+    it('returns recent errors grouped by op', async () => {
+      const recent = [
+        { op: 'vault_search', facade: 'vault', success: false, error: 'timeout', timestamp: 1000 },
+        { op: 'vault_search', facade: 'vault', success: false, error: 'timeout', timestamp: 1001 },
+        { op: 'brain_recommend', facade: 'brain', success: true, timestamp: 1002 },
+        { op: 'plan_create', facade: 'plan', success: false, error: 'invalid', timestamp: 1003 },
+      ];
+      const telemetry = makeTelemetryStub(
+        { errorsByOp: { vault_search: 2, plan_create: 1 }, slowestOps: [], avgDurationMs: 50 },
+        recent,
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_errors');
+
+      expect(res.success).toBe(true);
+      const data = res.data as {
+        errorCount: number;
+        errorsByOp: Record<string, number>;
+        recentErrors: Array<{ op: string }>;
+      };
+      expect(data.errorCount).toBe(3);
+      expect(data.errorsByOp).toEqual({ vault_search: 2, plan_create: 1 });
+      expect(data.recentErrors).toHaveLength(3);
+      expect(data.recentErrors[0].op).toBe('vault_search');
+    });
+
+    it('caps recentErrors at 20', async () => {
+      const recent = Array.from({ length: 30 }, (_, i) => ({
+        op: `op_${i}`,
+        facade: 'test',
+        success: false,
+        error: 'err',
+        timestamp: i,
+      }));
+      const telemetry = makeTelemetryStub(
+        { errorsByOp: {}, slowestOps: [], avgDurationMs: 0 },
+        recent,
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_errors');
+
+      const data = res.data as { recentErrors: unknown[] };
+      expect(data.recentErrors).toHaveLength(20);
+    });
+  });
+
+  describe('telemetry_slow_ops', () => {
+    it('filters by default threshold of 100ms', async () => {
+      const telemetry = makeTelemetryStub(
+        {
+          errorsByOp: {},
+          slowestOps: [
+            { op: 'vault_search', avgMs: 200 },
+            { op: 'brain_recommend', avgMs: 50 },
+            { op: 'plan_create', avgMs: 150 },
+          ],
+          avgDurationMs: 133,
+        },
+        [],
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_slow_ops', {});
+
+      expect(res.success).toBe(true);
+      const data = res.data as {
+        slowOps: Array<{ op: string; avgMs: number }>;
+        avgDurationMs: number;
+      };
+      expect(data.slowOps).toHaveLength(2);
+      expect(data.slowOps.map((o) => o.op)).toEqual(['vault_search', 'plan_create']);
+      expect(data.avgDurationMs).toBe(133);
+    });
+
+    it('respects custom threshold', async () => {
+      const telemetry = makeTelemetryStub(
+        {
+          errorsByOp: {},
+          slowestOps: [
+            { op: 'a', avgMs: 300 },
+            { op: 'b', avgMs: 200 },
+            { op: 'c', avgMs: 100 },
+          ],
+          avgDurationMs: 200,
+        },
+        [],
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_slow_ops', { threshold: 250 });
+
+      const data = res.data as { slowOps: Array<{ op: string }> };
+      expect(data.slowOps).toHaveLength(1);
+      expect(data.slowOps[0].op).toBe('a');
+    });
+
+    it('returns empty when no ops exceed threshold', async () => {
+      const telemetry = makeTelemetryStub(
+        { errorsByOp: {}, slowestOps: [{ op: 'fast', avgMs: 5 }], avgDurationMs: 5 },
+        [],
+      );
+      const ops = captureOps(createTelemetryOps({ telemetry } as unknown as AgentRuntime));
+      const res = await executeOp(ops, 'telemetry_slow_ops', { threshold: 100 });
+
+      const data = res.data as { slowOps: unknown[] };
+      expect(data.slowOps).toHaveLength(0);
+    });
+  });
+});