@goondocks/myco 0.18.1 → 0.19.0

package/dist/src/worker/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "@goondocks/myco-worker",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Myco team sync Cloudflare Worker",
-  "type": "module",
-  "scripts": {
-    "dev": "wrangler dev",
-    "deploy": "wrangler deploy",
-    "check": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250320.0",
-    "typescript": "^5.7.0",
-    "wrangler": "^4.0.0"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "agents": "^0.10.0",
-    "zod": "^4.3.6"
-  }
-}

package/dist/src/worker/src/auth.ts

@@ -1,31 +0,0 @@
-/**
- * Bearer token auth for the Myco team sync worker.
- */
-
-export interface AuthEnv {
-  MYCO_TEAM_API_KEY: string;
-}
-
-/**
- * Validate the Authorization header against the configured API key.
- * Returns null on success, or a 401 Response on failure.
- */
-export function validateAuth(request: Request, env: AuthEnv): Response | null {
-  const header = request.headers.get('Authorization');
-  if (!header) {
-    return new Response(JSON.stringify({ error: 'Missing Authorization header' }), {
-      status: 401,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-
-  const token = header.startsWith('Bearer ') ? header.slice(7) : '';
-  if (!token || token !== env.MYCO_TEAM_API_KEY) {
-    return new Response(JSON.stringify({ error: 'Invalid API key' }), {
-      status: 401,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-
-  return null;
-}

package/dist/src/worker/src/index.ts

@@ -1,476 +0,0 @@
-/**
- * Myco Team Sync — Cloudflare Worker
- *
- * Provides team-wide storage and vector search backed by D1 + Vectorize + Workers AI.
- * Each node (machine) pushes its outbox records here; the worker deduplicates by
- * content_hash and maintains a shared Vectorize index for semantic search.
- */
-
-import { initD1Schema } from './schema';
-import { validateAuth } from './auth';
-import { createMcpHandler } from 'agents/mcp';
-import { createMcpServerInstance } from './mcp/server';
-import { authenticateMcpRequest, ensureMcpToken, rotateMcpToken, getMcpTokenHash, MCP_TOKEN_KEY } from './mcp/auth';
-import { embedText, hydrateVectorMatches } from './search-helpers';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface Env {
-  MYCO_TEAM_DB: D1Database;
-  MYCO_TEAM_VECTORS: VectorizeIndex;
-  AI: Ai;
-  MYCO_TEAM_API_KEY: string;
-  SYNC_PROTOCOL_VERSION: string;
-  MYCO_SECRETS: KVNamespace;
-}
-
-/** Tables that support embedding in Vectorize. */
-const EMBEDDABLE_TABLES: Record<string, string> = {
-  spores: 'content',
-  sessions: 'summary',
-  plans: 'content',
-  artifacts: 'content',
-  skill_records: 'description',
-};
-
-/** All tables the sync endpoint accepts records for. */
-const SYNCED_TABLES = [
-  'sessions',
-  'prompt_batches',
-  'spores',
-  'entities',
-  'graph_edges',
-  'entity_mentions',
-  'resolution_events',
-  'plans',
-  'artifacts',
-  'digest_extracts',
-  'skill_candidates',
-  'skill_records',
-  'skill_usage',
-] as const;
-
-type SyncedTable = (typeof SYNCED_TABLES)[number];
-
-interface SyncRecord {
-  table: SyncedTable;
-  operation: 'upsert' | 'delete';
-  id: string;
-  machine_id: string;
-  content_hash?: string | null;
-  data: Record<string, unknown>;
-}
-
-interface ConnectPayload {
-  machine_id: string;
-  package_version?: string;
-  schema_version?: number;
-  sync_protocol_version?: number;
-}
-
-interface SyncPayload {
-  sync_protocol_version: number;
-  machine_id: string;
-  records: SyncRecord[];
-}
-
-interface SearchResult {
-  table: string;
-  id: string;
-  machine_id: string;
-  score: number;
-  data: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/** Whether initD1Schema has already run for this Worker instance. */
-let schemaInitialized = false;
-
-const JSON_HEADERS = { 'Content-Type': 'application/json' } as const;
-const DEFAULT_TOP_K = 10;
-const MAX_TOP_K = 50;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
-}
-
-function errorResponse(message: string, status: number): Response {
-  return jsonResponse({ error: message }, status);
-}
-
-function epochSeconds(): number {
-  return Math.floor(Date.now() / 1000);
-}
-
-/**
- * Build a Vectorize namespace ID for a record: `{table}:{id}:{machine_id}`.
- */
-function vectorId(table: string, id: string, machineId: string): string {
-  return `${table}:${id}:${machineId}`;
-}
-
-
-/**
- * Build column names and placeholders for an INSERT OR REPLACE from a data object.
- * Always includes id and machine_id.
- */
-function buildInsertParts(
-  table: string,
-  data: Record<string, unknown>,
-  id: string,
-  machineId: string,
-): { sql: string; values: unknown[] } {
-  const row: Record<string, unknown> = { id, machine_id: machineId, ...data, synced_at: epochSeconds() };
-
-  // Remove fields that don't belong in D1 (local-only fields)
-  delete row.embedded;
-
-  const columns = Object.keys(row);
-  const placeholders = columns.map(() => '?').join(', ');
-  const quotedColumns = columns.map((c) => (c === 'user' ? `"user"` : c)).join(', ');
-
-  return {
-    sql: `INSERT OR REPLACE INTO ${table} (${quotedColumns}) VALUES (${placeholders})`,
-    values: Object.values(row),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Route handlers
-// ---------------------------------------------------------------------------
-
-async function handleHealth(env: Env): Promise<Response> {
-  const [countResult, storedToken] = await Promise.all([
-    env.MYCO_TEAM_DB.prepare('SELECT COUNT(*) as count FROM nodes').first<{ count: number }>(),
-    env.MYCO_SECRETS.get(MCP_TOKEN_KEY),
-  ]);
-
-  const count = countResult?.count ?? 0;
-  const mcpTokenHash = storedToken ? getMcpTokenHash(storedToken) : null;
-
-  return jsonResponse({ status: 'ok', nodes: count, mcp_token_hash: mcpTokenHash });
-}
-
-async function handleConnect(request: Request, env: Env): Promise<Response> {
-  const body = (await request.json()) as ConnectPayload;
-  if (!body.machine_id) {
-    return errorResponse('machine_id is required', 400);
-  }
-
-  const now = epochSeconds();
-
-  await env.MYCO_TEAM_DB.prepare(
-    `INSERT INTO nodes (machine_id, package_version, schema_version, sync_protocol_version, last_seen, registered_at)
-     VALUES (?, ?, ?, ?, ?, ?)
-     ON CONFLICT (machine_id) DO UPDATE SET
-       package_version = excluded.package_version,
-       schema_version = excluded.schema_version,
-       sync_protocol_version = excluded.sync_protocol_version,
-       last_seen = excluded.last_seen`,
-  ).bind(
-    body.machine_id,
-    body.package_version ?? null,
-    body.schema_version ?? null,
-    body.sync_protocol_version ?? null,
-    now,
-    now,
-  ).run();
-
-  // Return team config
-  const configRows = await env.MYCO_TEAM_DB.prepare('SELECT key, value FROM team_config').all<{
-    key: string;
-    value: string;
-  }>();
-  const config: Record<string, string> = {};
-  for (const row of configRows.results) {
-    config[row.key] = row.value;
-  }
-
-  // MCP token is stored in KV (encrypted at rest), not in team_config
-  const mcpToken = await ensureMcpToken(env.MYCO_SECRETS);
-
-  return jsonResponse({
-    status: 'connected',
-    sync_protocol_version: parseInt(env.SYNC_PROTOCOL_VERSION, 10),
-    config,
-    mcp_token: mcpToken,
-    mcp_endpoint: '/mcp',
-  });
-}
-
-async function handleSync(request: Request, env: Env): Promise<Response> {
-  const body = (await request.json()) as SyncPayload;
-
-  // Version check
-  const serverVersion = parseInt(env.SYNC_PROTOCOL_VERSION, 10);
-  if (body.sync_protocol_version !== serverVersion) {
-    return errorResponse(
-      `Protocol version mismatch: client=${body.sync_protocol_version}, server=${serverVersion}`,
-      409,
-    );
-  }
-
-  if (!Array.isArray(body.records) || body.records.length === 0) {
-    return jsonResponse({ synced: 0, skipped: 0, errors: [] });
-  }
-
-  let synced = 0;
-  let skipped = 0;
-  const errors: Array<{ id: string; table: string; error: string }> = [];
-
-  // Collect embedding tasks so they can be parallelized after DB writes
-  const embeddingTasks: Array<() => Promise<void>> = [];
-
-  for (const record of body.records) {
-    try {
-      if (!SYNCED_TABLES.includes(record.table)) {
-        errors.push({ id: record.id, table: record.table, error: `Unknown table: ${record.table}` });
-        continue;
-      }
-
-      if (record.operation === 'delete') {
-        await handleDelete(env, record);
-        synced++;
-        continue;
-      }
-
-      // Check content_hash — skip if unchanged
-      if (record.content_hash) {
-        const existing = await env.MYCO_TEAM_DB.prepare(
-          `SELECT content_hash FROM ${record.table} WHERE id = ? AND machine_id = ?`,
-        )
-          .bind(record.id, record.machine_id)
-          .first<{ content_hash: string | null }>();
-
-        if (existing?.content_hash === record.content_hash) {
-          skipped++;
-          continue;
-        }
-      }
-
-      // INSERT OR REPLACE into D1
-      const { sql, values } = buildInsertParts(record.table, record.data, record.id, record.machine_id);
-      await env.MYCO_TEAM_DB.prepare(sql).bind(...values).run();
-
-      // Queue embedding if the table has embeddable content
-      const embeddableField = EMBEDDABLE_TABLES[record.table];
-      if (embeddableField) {
-        const textContent = record.data[embeddableField] as string | undefined;
-        if (textContent) {
-          const { table, id, machine_id } = record;
-          if (table === 'spores' && record.data.status === 'superseded') {
-            embeddingTasks.push(() => deleteVector(env, table, id, machine_id));
-          } else {
-            // Include domain-specific metadata for richer search results
-            const extra: Record<string, string> = {};
-            if (table === 'skill_records' && record.data.name) extra.name = record.data.name as string;
-            if (table === 'spores' && record.data.observation_type) extra.observation_type = record.data.observation_type as string;
-            embeddingTasks.push(() => embedAndUpsert(env, table, id, machine_id, textContent, extra));
-          }
-        }
-      }
-
-      synced++;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      errors.push({ id: record.id, table: record.table, error: message });
-    }
-  }
-
-  // Run all embedding tasks in parallel
-  if (embeddingTasks.length > 0) {
-    await Promise.allSettled(embeddingTasks.map((t) => t()));
-  }
-
-  // Update node last_seen
-  await env.MYCO_TEAM_DB.prepare('UPDATE nodes SET last_seen = ? WHERE machine_id = ?')
-    .bind(epochSeconds(), body.machine_id)
-    .run();
-
-  return jsonResponse({ synced, skipped, errors });
-}
-
-async function handleDelete(env: Env, record: SyncRecord): Promise<void> {
-  await env.MYCO_TEAM_DB.prepare(`DELETE FROM ${record.table} WHERE id = ? AND machine_id = ?`)
-    .bind(record.id, record.machine_id)
-    .run();
-
-  // Remove from Vectorize if embeddable
-  if (record.table in EMBEDDABLE_TABLES) {
-    await deleteVector(env, record.table, record.id, record.machine_id);
-  }
-}
-
-async function embedAndUpsert(
-  env: Env,
-  table: string,
-  id: string,
-  machineId: string,
-  text: string,
-  extra?: Record<string, string>,
-): Promise<void> {
-  const vector = await embedText(env.AI, text);
-  const vid = vectorId(table, id, machineId);
-  await env.MYCO_TEAM_VECTORS.upsert([
-    {
-      id: vid,
-      values: vector,
-      metadata: { table, id, machine_id: machineId, ...extra },
-    },
-  ]);
-}
-
-async function deleteVector(env: Env, table: string, id: string, machineId: string): Promise<void> {
-  const vid = vectorId(table, id, machineId);
-  try {
-    await env.MYCO_TEAM_VECTORS.deleteByIds([vid]);
-  } catch {
-    // Vector may not exist — safe to ignore
-  }
-}
-
-async function handleSearch(request: Request, env: Env): Promise<Response> {
-  const url = new URL(request.url);
-  const query = url.searchParams.get('q');
-  if (!query) {
-    return errorResponse('Missing query parameter "q"', 400);
-  }
-
-  const topK = Math.min(parseInt(url.searchParams.get('top_k') ?? String(DEFAULT_TOP_K), 10), MAX_TOP_K);
-
-  const queryVector = await embedText(env.AI, query);
-  const matches = await env.MYCO_TEAM_VECTORS.query(queryVector, { topK, returnMetadata: 'all' });
-
-  const validMatches = matches.matches
-    .filter((m) => m.metadata)
-    .map((m) => ({ metadata: m.metadata as { table: string; id: string; machine_id: string }, score: m.score }));
-
-  const results = await hydrateVectorMatches(env.MYCO_TEAM_DB, validMatches);
-
-  return jsonResponse({ results: results.map((r) => ({ table: r.type, ...r })) });
-}
-
-async function handleGetConfig(env: Env): Promise<Response> {
-  const rows = await env.MYCO_TEAM_DB.prepare('SELECT key, value FROM team_config').all<{
-    key: string;
-    value: string;
-  }>();
-
-  const config: Record<string, string> = {};
-  for (const row of rows.results) {
-    config[row.key] = row.value;
-  }
-
-  return jsonResponse({
-    config,
-    sync_protocol_version: parseInt(env.SYNC_PROTOCOL_VERSION, 10),
-  });
-}
-
-async function handlePutConfig(request: Request, env: Env): Promise<Response> {
-  const body = (await request.json()) as Record<string, string>;
-
-  const entries = Object.entries(body);
-  if (entries.length === 0) {
-    return errorResponse('Empty config body', 400);
-  }
-
-  const statements = entries.map(([key, value]) =>
-    env.MYCO_TEAM_DB.prepare('INSERT OR REPLACE INTO team_config (key, value) VALUES (?, ?)').bind(key, value),
-  );
-
-  await env.MYCO_TEAM_DB.batch(statements);
-
-  return jsonResponse({ updated: entries.length });
-}
-
-// ---------------------------------------------------------------------------
-// Router
-// ---------------------------------------------------------------------------
-
-export default {
-  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-    const url = new URL(request.url);
-    const path = url.pathname;
-    const method = request.method;
-
-    // Health — no auth required
-    if (method === 'GET' && path === '/health') {
-      try {
-        if (!schemaInitialized) {
-          await initD1Schema(env.MYCO_TEAM_DB);
-          schemaInitialized = true;
-        }
-        return await handleHealth(env);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return errorResponse(`Health check failed: ${message}`, 500);
-      }
-    }
-
-    // MCP routes — separate auth from sync routes
-    if (path.startsWith('/mcp')) {
-      if (!schemaInitialized) {
-        await initD1Schema(env.MYCO_TEAM_DB);
-        schemaInitialized = true;
-      }
-
-      // Token rotation — authenticated with team API key
-      if (path === '/mcp/rotate' && method === 'POST') {
-        const rotateAuthError = validateAuth(request, env);
-        if (rotateAuthError) return rotateAuthError;
-        const newToken = await rotateMcpToken(env.MYCO_SECRETS);
-        return jsonResponse({ token: newToken });
-      }
-
-      // MCP protocol — authenticated with MCP access token
-      const mcpAuthError = await authenticateMcpRequest(request, env.MYCO_SECRETS);
-      if (mcpAuthError) return mcpAuthError;
-
-      const server = createMcpServerInstance(env);
-      const handler = createMcpHandler(server);
-      return handler(request, env, ctx);
-    }
-
-    // All other routes require auth
-    const authError = validateAuth(request, env);
-    if (authError) return authError;
-
-    if (!schemaInitialized) {
-      await initD1Schema(env.MYCO_TEAM_DB);
-      schemaInitialized = true;
-    }
-
-    try {
-      if (method === 'POST' && path === '/connect') {
-        return await handleConnect(request, env);
-      }
-      if (method === 'POST' && path === '/sync') {
-        return await handleSync(request, env);
-      }
-      if (method === 'GET' && path === '/search') {
-        return await handleSearch(request, env);
-      }
-      if (method === 'GET' && path === '/config') {
-        return await handleGetConfig(env);
-      }
-      if (method === 'PUT' && path === '/config') {
-        return await handlePutConfig(request, env);
-      }
-
-      return errorResponse('Not found', 404);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return errorResponse(message, 500);
-    }
-  },
-} satisfies ExportedHandler<Env>;

package/dist/src/worker/src/mcp/auth.ts

@@ -1,65 +0,0 @@
-/**
- * MCP access token auth for the Myco cloud MCP server.
- *
- * Tokens are stored in Workers KV (MYCO_SECRETS namespace) under the key 'mcp_access_token'.
- * KV provides AES-256-GCM encryption at rest — the Cloudflare-native approach for
- * runtime-managed secrets. This is separate from the worker's MYCO_TEAM_API_KEY auth
- * used for sync routes.
- */
-
-export const MCP_TOKEN_KEY = 'mcp_access_token';
-
-export function generateMcpToken(): string {
-  return crypto.randomUUID();
-}
-
-export function getMcpTokenHash(token: string): string {
-  // Non-cryptographic hash for change detection, returns 8 hex chars
-  let hash = 0;
-  for (let i = 0; i < token.length; i++) {
-    hash = ((hash << 5) - hash + token.charCodeAt(i)) | 0;
-  }
-  return Math.abs(hash).toString(16).padStart(8, '0').slice(0, 8);
-}
-
-export async function validateMcpToken(kv: KVNamespace, token: string): Promise<boolean> {
-  const stored = await kv.get(MCP_TOKEN_KEY);
-  if (!stored) return false;
-  return stored === token;
-}
-
-export async function ensureMcpToken(kv: KVNamespace): Promise<string> {
-  const existing = await kv.get(MCP_TOKEN_KEY);
-  if (existing) return existing;
-  const token = generateMcpToken();
-  await kv.put(MCP_TOKEN_KEY, token);
-  return token;
-}
-
-export async function rotateMcpToken(kv: KVNamespace): Promise<string> {
-  const token = generateMcpToken();
-  await kv.put(MCP_TOKEN_KEY, token);
-  return token;
-}
-
-export async function authenticateMcpRequest(
-  request: Request,
-  kv: KVNamespace,
-): Promise<Response | null> {
-  const header = request.headers.get('Authorization');
-  if (!header) {
-    return new Response(JSON.stringify({ error: 'Missing Authorization header' }), {
-      status: 401,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-  const token = header.startsWith('Bearer ') ? header.slice(7) : '';
-  const valid = await validateMcpToken(kv, token);
-  if (!valid) {
-    return new Response(JSON.stringify({ error: 'Invalid MCP access token' }), {
-      status: 401,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-  return null;
-}

package/dist/src/worker/src/mcp/server.ts

@@ -1,53 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { Env } from '../index';
-import { handleSearch } from './tools/search';
-import { handleContext } from './tools/context';
-import { handleGet } from './tools/get';
-import { handleSessions } from './tools/sessions';
-import { handleGraph } from './tools/graph';
-import { handleSkills } from './tools/skills';
-import { handleTeam } from './tools/team';
-
-export function createMcpServerInstance(env: Env): McpServer {
-  const server = new McpServer({ name: 'myco', version: '1.0.0' });
-
-  server.tool('myco_search', 'Semantic and keyword search across all project knowledge — spores, sessions, plans, artifacts. Returns ranked results with content previews.', {
-    query: z.string().describe('The search query'),
-    types: z.array(z.string()).optional().describe('Filter to content types: spores, sessions, plans, artifacts'),
-    limit: z.number().min(1).max(50).default(10).describe('Maximum results'),
-  }, async (args) => handleSearch(args, env));
-
-  server.tool('myco_context', 'Pre-synthesized project digest. Start here to understand the project. Three tiers: 1500 (executive), 5000 (deep onboarding), 10000 (comprehensive).', {
-    tier: z.number().optional().describe('Digest depth: 1500, 5000 (default), or 10000'),
-  }, async (args) => handleContext(args, env));
-
-  server.tool('myco_get', 'Retrieve a specific item by ID and type. Use after search to get full details.', {
-    id: z.string().describe('The item ID'),
-    type: z.enum(['session', 'spore', 'plan', 'artifact', 'skill']).describe('The item type'),
-  }, async (args) => handleGet(args, env));
-
-  server.tool('myco_sessions', 'List and filter coding sessions. Useful for recent activity, work by branch or agent.', {
-    limit: z.number().min(1).max(100).default(20).optional().describe('Maximum sessions'),
-    status: z.string().optional().describe('Filter: active, completed'),
-    agent: z.string().optional().describe('Filter: claude, codex, cursor, etc.'),
-    branch: z.string().optional().describe('Filter by git branch'),
-    since: z.string().optional().describe('ISO date — sessions after this date'),
-  }, async (args) => handleSessions(args, env));
-
-  server.tool('myco_graph', 'Traverse the knowledge graph from an entity or note. Returns edges and connected entities.', {
-    node_id: z.string().describe('Entity or note ID to traverse from'),
-    direction: z.enum(['incoming', 'outgoing', 'both']).default('both').optional().describe('Edge direction'),
-  }, async (args) => handleGraph(args, env));
-
-  server.tool('myco_skills', 'List project skills — reusable patterns extracted from project knowledge.', {
-    status: z.string().optional().describe('Filter: active, draft, retired'),
-    limit: z.number().min(1).max(100).default(50).optional().describe('Maximum skills'),
-  }, async (args) => handleSkills(args, env));
-
-  // handleTeam takes only env (no args) since it has no parameters
-  server.tool('myco_team', 'List team nodes — machines/developers connected to this project with sync status.', {},
-    async () => handleTeam(env));
-
-  return server;
-}

package/dist/src/worker/src/mcp/tools/context.ts

@@ -1,13 +0,0 @@
-import type { Env } from '../../index';
-
-export async function handleContext(args: { tier?: number }, env: Pick<Env, 'MYCO_TEAM_DB'>) {
-  const tier = args.tier ?? 5000;
-  const row = await env.MYCO_TEAM_DB.prepare(
-    `SELECT id, tier, content, generated_at FROM digest_extracts WHERE tier = ? ORDER BY generated_at DESC LIMIT 1`,
-  ).bind(tier).first<{ id: string; tier: number; content: string; generated_at: number }>();
-
-  if (!row) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify({ content: null, tier, message: `No digest available at tier ${tier}` }) }] };
-  }
-  return { content: [{ type: 'text' as const, text: JSON.stringify({ content: row.content, tier: row.tier, generated_at: row.generated_at }) }] };
-}

package/dist/src/worker/src/mcp/tools/get.ts

@@ -1,15 +0,0 @@
-import type { Env } from '../../index';
-
-const TYPE_TO_TABLE: Record<string, string> = {
-  session: 'sessions', spore: 'spores', plan: 'plans', artifact: 'artifacts', skill: 'skill_records',
-};
-
-export async function handleGet(args: { id: string; type: string }, env: Pick<Env, 'MYCO_TEAM_DB'>) {
-  const table = TYPE_TO_TABLE[args.type];
-  if (!table) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: `Unknown type: ${args.type}` }) }] };
-
-  const row = await env.MYCO_TEAM_DB.prepare(`SELECT * FROM ${table} WHERE id = ? LIMIT 1`).bind(args.id).first<Record<string, unknown>>();
-  if (!row) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: `${args.type} '${args.id}' not found` }) }] };
-
-  return { content: [{ type: 'text' as const, text: JSON.stringify(row) }] };
-}