@ezmodo/mcp-server 0.14.4 → 0.17.1

package/config/endpoint-map.js

@@ -131,27 +131,6 @@ export const ENDPOINT_MAP = {
   'mcpRemoveAccessEntry': { route: 'mcp/v1/access/entries', method: 'DELETE' },
   'mcpCheckAccess': { route: 'mcp/v1/access/check', method: 'POST' },
 
-  // Components (project-scoped codebase areas)
-  'mcpCreateComponent': { route: 'mcp/v1/components', method: 'POST' },
-  'mcpListComponents': { route: 'mcp/v1/components', method: 'GET' },
-  'mcpUpdateComponent': { route: 'mcp/v1/components', method: 'PUT' },
-  'mcpDeleteComponent': { route: 'mcp/v1/components', method: 'DELETE' },
-  'mcpGetComponentStats': { route: 'mcp/v1/components/stats', method: 'GET' },
-  'mcpGetComponentDependencyGraph': { route: 'mcp/v1/components/dependency-graph', method: 'GET' },
-  // E-223: screen→screen navigation edges (the screen-flow map).
-  'mcpGetComponentNavigation': { route: 'mcp/v1/components/navigation', method: 'GET' },
-  'mcpAddComponentNavigation': { route: 'mcp/v1/components/navigation', method: 'POST' },
-  'mcpRemoveComponentNavigation': { route: 'mcp/v1/components/navigation', method: 'DELETE' },
-  // E-239 #2409: re-derive the flow map from code instead of hand-drawing it.
-  'mcpDeriveComponentNavigation': { route: 'mcp/v1/components/navigation/derive', method: 'POST' },
-  'mcpAddComponentDependency': { route: 'mcp/v1/components/dependencies', method: 'POST' },
-  'mcpRemoveComponentDependency': { route: 'mcp/v1/components/dependencies', method: 'DELETE' },
-  // E-168: unified UI inventory — Components span kinds area|screen|page|component.
-  // discover proposes page/component surfaces from the Context Manifest;
-  // import bulk-creates surfaces (optionally nested and/or feature-linked).
-  'mcpDiscoverComponents': { route: 'mcp/v1/components/discover', method: 'GET' },
-  'mcpImportComponents': { route: 'mcp/v1/components/import', method: 'POST' },
-
   // Polymorphic links — single CRUD surface for any entity_links row
   // (blocked_by, relates_to) across tasks, epics, projects, documents.
   'mcpAddLink':    { route: 'mcp/v1/links', method: 'POST' },
@@ -211,6 +190,8 @@ export const ENDPOINT_MAP = {
   'mcpSearchFeatures': { route: 'mcp/v1/features/search', method: 'GET' },
   'mcpLinkFeatureArtifact': { route: 'mcp/v1/features/link', method: 'POST' },
   'mcpUnlinkFeatureArtifact': { route: 'mcp/v1/features/link', method: 'DELETE' },
+  'mcpListFeaturePaths': { route: 'mcp/v1/features/paths', method: 'GET' },
+  'mcpSetFeaturePaths': { route: 'mcp/v1/features/paths', method: 'PUT' },
   'mcpPromoteEpicToFeature': { route: 'mcp/v1/features/promote-epic', method: 'POST' },
   'mcpGenerateHowItWorks': { route: 'mcp/v1/features/generate-how-it-works', method: 'POST' },
   'mcpApplyHowItWorks': { route: 'mcp/v1/features/apply-how-it-works', method: 'POST' },
@@ -270,6 +251,9 @@ export const ENDPOINT_MAP = {
   'mcpUpdateCatalog': { route: 'mcp/v1/catalogs', method: 'PUT' },
   'mcpDeleteCatalog': { route: 'mcp/v1/catalogs', method: 'DELETE' },
   'mcpSnapshotCatalog': { route: 'mcp/v1/catalogs/snapshot', method: 'POST' },
+  'mcpDiscoverScreens': { route: 'mcp/v1/screens/discover', method: 'GET' },
+  'mcpImportScreens': { route: 'mcp/v1/screens/import', method: 'POST' },
+  'mcpSyncScreens': { route: 'mcp/v1/screens/sync', method: 'POST' },
   'mcpLinkCatalog': { route: 'mcp/v1/catalogs/link', method: 'POST' },
   'mcpUnlinkCatalog': { route: 'mcp/v1/catalogs/link', method: 'DELETE' },
   // Item-level links (E-218) — attach work or an external URL to one catalog entry

package/handlers/catalogs.js

@@ -24,8 +24,12 @@ export async function manageCatalog(args) {
   case 'link': return params.itemKey ? linkCatalogItem(params) : linkCatalogArtifact(params);
   case 'unlink': return params.itemKey ? unlinkCatalogItem(params) : unlinkCatalogArtifact(params);
   case 'snapshot': return snapshotCatalog(params);
+  case 'discover_screens': return discoverScreens(params);
+  case 'import_screens': return importScreens(params);
+  case 'sync_screens': return syncScreens(params);
   default:
-    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, or snapshot.`);
+    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, snapshot, ` +
+      'discover_screens, import_screens, or sync_screens.');
   }
 }
 
@@ -167,3 +171,37 @@ async function snapshotCatalog({ catalogId, mode, snapshot, upsertItems, removeK
   if (source) params.source = source;
   return callZephlyAPI('mcpSnapshotCatalog', params);
 }
+
+// --- Screens catalog (E-258) ---
+
+// Screens and pages the project's manifest shows that its screens catalog does
+// not hold yet. Read-only.
+async function discoverScreens({ projectId }) {
+  if (!projectId) {
+    throw new Error('projectId is required for discover_screens');
+  }
+  return callZephlyAPI('mcpDiscoverScreens', { projectId });
+}
+
+// Add screens to the project's screens catalog (created on first use),
+// optionally linking every one to a feature.
+async function importScreens({ projectId, screens, featureId }) {
+  if (!projectId) {
+    throw new Error('projectId is required for import_screens');
+  }
+  if (!Array.isArray(screens) || screens.length === 0) {
+    throw new Error('screens must be a non-empty array for import_screens');
+  }
+  const params = { projectId, screens };
+  if (featureId) params.featureId = featureId;
+  return callZephlyAPI('mcpImportScreens', params);
+}
+
+// Reconcile the project's screens catalog with its synced manifest and
+// re-derive the screen flow map (navigates_to between catalog items).
+async function syncScreens({ projectId }) {
+  if (!projectId) {
+    throw new Error('projectId is required for sync_screens');
+  }
+  return callZephlyAPI('mcpSyncScreens', { projectId });
+}

package/handlers/context-manifest.js

@@ -374,7 +374,6 @@ async function handleEntityContext(args) {
     };
     // Map entityType+entityId to the correct graph param
     if (entityType === 'task') graphParams.taskId = entityId;
-    else if (entityType === 'component') graphParams.componentId = entityId;
     else if (entityType === 'file') graphParams.filePath = entityId;
     else if (entityType === 'tag') graphParams.tagId = entityId;
 
@@ -389,7 +388,6 @@ async function handleEntityContext(args) {
   if (sections.includes('impact')) {
     const impactParams = { projectId, depth: args.depth };
     if (entityType === 'file') impactParams.filePath = entityId;
-    else if (entityType === 'component') impactParams.componentId = entityId;
 
     promises.push(
       callZephlyAPI('mcpAnalyzeImpact', impactParams)
@@ -566,8 +564,6 @@ function getDefaultIncludes(entityType) {
   case 'task':
   case 'epic':
     return ['graph'];
-  case 'component':
-    return ['graph', 'impact'];
   case 'file':
     return ['dependencies', 'impact'];
   case 'tag':

package/handlers/epics.js

@@ -3,7 +3,7 @@
  * Handler functions for epic-related MCP tools
  *
  * Project-First Hierarchy: Epics belong to projects (required),
- * with optional component grouping and milestone linking.
+ * with optional milestone linking.
  *
  * Auto-assignment: When creating epics, automatically applies matching tags
  * based on content analysis against the local project cache.

package/handlers/features.js

@@ -20,12 +20,13 @@ export async function manageFeature(args) {
   case 'delete': return deleteFeature(params);
   case 'link': return linkFeatureArtifact(params);
   case 'unlink': return unlinkFeatureArtifact(params);
+  case 'paths': return setFeaturePaths(params);
   case 'promote_epic': return promoteEpic(params);
   case 'generate_how_it_works': return generateHowItWorks(params);
   case 'apply_how_it_works': return applyHowItWorks(params);
   case 'apply_init': return applyInit(params);
   default:
-    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, promote_epic, generate_how_it_works, apply_how_it_works, or apply_init.`);
+    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, paths, promote_epic, generate_how_it_works, apply_how_it_works, or apply_init.`);
   }
 }
 
@@ -35,7 +36,7 @@ export async function manageFeature(args) {
  * - organizationId only → list (or tree when tree=true).
  */
 export async function getFeature(args) {
-  const { tree, includeLinks, includeDetail, featureId, featureSlug, organizationId, ...filters } = args;
+  const { tree, includeLinks, includeDetail, includePaths, featureId, featureSlug, organizationId, ...filters } = args;
   const isSingleLookup = featureId || (featureSlug && organizationId);
 
   if (isSingleLookup) {
@@ -50,6 +51,10 @@ export async function getFeature(args) {
       const links = await callZephlyAPI('mcpListFeatureLinks', { featureId: lookupId });
       result.links = links?.links ?? links;
     }
+    if (includePaths && lookupId) {
+      const paths = await callZephlyAPI('mcpListFeaturePaths', { featureId: lookupId });
+      result.paths = paths?.paths ?? paths;
+    }
     return result;
   }
 
@@ -110,6 +115,12 @@ async function unlinkFeatureArtifact({ featureId, targetType, targetId }) {
   return callZephlyAPI('mcpUnlinkFeatureArtifact', { featureId, targetType, targetId });
 }
 
+// Add, remove or replace the code paths a feature owns (E-258). Paths are what
+// auto-link work to the feature when it touches those files.
+async function setFeaturePaths({ featureId, pathsMode, paths }) {
+  return callZephlyAPI('mcpSetFeaturePaths', { featureId, mode: pathsMode || 'add', paths });
+}
+
 async function promoteEpic({ epicId }) {
   return callZephlyAPI('mcpPromoteEpicToFeature', { epicId });
 }

package/handlers/git-context.js

@@ -19,7 +19,6 @@ export { isCacheFresh };
 import { getProject } from './projects.js';
 import { listRepositories } from './github.js';
 import { getOrganization } from './organizations.js';
-import { listComponents } from './components.js';
 import { getLogger } from '../lib/logger.js';
 import { listTags } from './tags.js';
 import { CONFIG } from '../config/index.js';
@@ -71,28 +70,6 @@ function legacyConfigNotice(legacyConfigPath) {
   };
 }
 
-/**
- * Fetch lightweight component summaries (id, name, description) for a project.
- * Filtered to kind='area' (E-168): this list is the coarse codebase-area set
- * agents use to pick a task's componentId, and it must match the web task
- * picker (which also filters to area). Without the filter, UI-inventory rows
- * (screen/page/component) would leak into task routing. Returns an empty array
- * on failure (non-fatal).
- */
-async function fetchComponentSummaries(projectId) {
-  try {
-    const result = await listComponents({ projectId, kind: 'area' });
-    if (!result?.components) return [];
-    return result.components.map((c) => ({
-      id: c.id,
-      name: c.name,
-      description: c.description || '',
-    }));
-  } catch {
-    return [];
-  }
-}
-
 /**
  * Fetch lightweight tag summaries (id, name, color, category) for an organization.
  * Returns an empty array on failure (non-fatal).
@@ -168,9 +145,9 @@ no exceptions unless the user explicitly says to work on an existing task.
 **Single-scope work** (bug fix, small feature, config change, docs update):
 - Create a **task** with \`manage_task action:"create"\`:
   - \`projectId\` from cached context
-  - \`componentId\` — pick the single most relevant component from the
-    project context. Each task belongs to exactly one component.
-    Get the list via \`get_current_project_context()\`.
+  - \`changedFiles\` — the paths you expect to touch; they resolve to the
+    features that own them
+  - \`links\` — the feature the work advances (find it with \`search_features\`)
   - Descriptive \`title\` and \`description\` (informed by \`get_context\`)
   - \`steps\` array with actionable steps referencing specific files
   - \`priority\` based on context (low / medium / high / urgent)
@@ -551,12 +528,11 @@ export async function getCurrentProjectContext(args) {
             workingDirectory: currentDir,
             configPath,
             allProjects: config.projects || null,
-            components: config.components || [],
             tags: config.tags || [],
             autoGenerateTestCases: config.settings?.aiConfig?.autoGenerateTestCases || false,
             organizeResponseMode: config.settings?.aiConfig?.organizeResponseMode || 'raw_snapshot',
             // The words this project's type uses (E-107). Cached alongside
-            // components and tags because it changes about as often, and an
+            // tags because it changes about as often, and an
             // agent needs it on every session, not on a second round trip.
             // Absent means plain English — a project type with no template.
             projectType: config.projectType || null,
@@ -614,18 +590,17 @@ export async function getCurrentProjectContext(args) {
           validation.warnings.push('Could not validate organization access');
         }
 
-        // Refresh components and tags lists
-        const [components, tags] = await Promise.all([
-          fetchComponentSummaries(activeProject.id),
-          fetchTagSummaries(config.organizationId),
-        ]);
+        // Refresh the tags list
+        const tags = await fetchTagSummaries(config.organizationId);
 
         // Update config on disk with fresh data (non-fatal)
         if (validation.projectExists && validation.organizationExists) {
           try {
             config.orgName = orgName;
             config.lastUpdatedAt = new Date().toISOString();
-            config.components = components;
+            // Components were retired (E-258); drop the list a config written
+            // by an older server still carries.
+            delete config.components;
             config.tags = tags;
             config.projectType = projectType;
             config.terminology = terminology;
@@ -650,7 +625,6 @@ export async function getCurrentProjectContext(args) {
           workingDirectory: currentDir,
           configPath,
           allProjects: config.projects || null,
-          components,
           tags,
           autoGenerateTestCases: projectSettings?.aiConfig?.autoGenerateTestCases || false,
           organizeResponseMode: projectSettings?.aiConfig?.organizeResponseMode || 'raw_snapshot',
@@ -836,11 +810,8 @@ export async function initializeProjectContext(args) {
       throw new Error(`Organization ${organizationId} not found or not accessible`);
     }
 
-    // Step 5: Fetch components and tags
-    const [components, tags] = await Promise.all([
-      fetchComponentSummaries(projectId),
-      fetchTagSummaries(organizationId),
-    ]);
+    // Step 5: Fetch tags
+    const tags = await fetchTagSummaries(organizationId);
 
     // Step 6: Build config
     const config = {
@@ -853,7 +824,6 @@ export async function initializeProjectContext(args) {
       projectName: projectContext.project?.name || projectContext.name || 'Unknown Project',
       environment: CONFIG.environment, // staging, production, or dev
       lastUpdatedAt: new Date().toISOString(),
-      components,
       tags,
       settings: {
         aiConfig: projectContext.settings?.aiConfig || projectContext.project?.settings?.aiConfig || null,

package/handlers/index.js

@@ -9,7 +9,6 @@
 import * as organizationHandlers from './organizations.js';
 import * as projectHandlers from './projects.js';
 import * as epicHandlers from './epics.js';
-import * as componentHandlers from './components.js';
 import * as milestoneHandlers from './milestones.js';
 import * as featureHandlers from './features.js';
 import * as decisionHandlers from './decisions.js';
@@ -60,10 +59,6 @@ export const HANDLERS = {
   list_epics: epicHandlers.listEpics,
   get_epic: epicHandlers.getEpic,
 
-  // Components
-  manage_component: componentHandlers.manageComponent,
-  list_components: componentHandlers.listComponents,
-
   // Milestones
   manage_milestone: milestoneHandlers.manageMilestone,
   get_milestone: milestoneHandlers.getMilestone,

package/handlers/links.js

@@ -7,7 +7,7 @@
  */
 
 import {
-  resolvePathsToComponents,
+  resolvePathsToFeatures,
   previewEntityLinks,
   partitionProposals,
   attachSuggestionIds,
@@ -107,20 +107,27 @@ export async function listLinks({
 }
 
 /**
- * resolve_links — which components own these files?
+ * resolve_links — which features own these files?
  *
  * The read that makes linking cheap: an agent asks once, before creating work,
- * and gets back the entities it should attach rather than having to know the
- * component inventory. Returns `unresolved` too, because a path nothing covers
- * is itself information — it usually means the inventory has a gap.
+ * and gets back the features it should attach rather than having to know which
+ * code paths each one owns. Returns `unmatchedPaths` too, because a path no
+ * feature owns is itself information — it usually means the feature map has a
+ * gap.
+ *
+ * Split by what the engine would do with them: a feature that solely owns the
+ * path links on its own; a path several features share is a choice for the
+ * caller to make.
  */
 export async function resolveLinks({ projectId, paths }) {
-  const { matches, unresolved } = await resolvePathsToComponents({ projectId, paths });
+  const { features, unresolved } = await resolvePathsToFeatures({ projectId, paths });
   return {
-    deterministic: matches.filter((m) => m.score >= 1),
-    probable: matches.filter((m) => m.score < 1),
+    features: {
+      owned: features.filter((f) => !f.ambiguous),
+      shared: features.filter((f) => f.ambiguous),
+    },
     unmatchedPaths: unresolved,
-    count: matches.length,
+    count: features.length,
   };
 }
 
@@ -135,12 +142,11 @@ export async function previewLinks({
   subjectType,
   subjectId,
   paths,
-  componentId,
   epicId,
   trigger,
 }) {
   const { proposals } = await previewEntityLinks({
-    projectId, subjectType, subjectId, paths, componentId, epicId, trigger,
+    projectId, subjectType, subjectId, paths, epicId, trigger,
   });
   const { autoLinked, linkSuggestions } = partitionProposals(proposals);
 

package/handlers/projects.js

@@ -46,7 +46,7 @@ async function createProject(args) {
 // Update an existing project. Only the fields present in `args` are changed —
 // the server leaves anything unmentioned alone. This is the path that lets an
 // agent set gitUrl/gitProvider after creation, which is what commit-to-task
-// linking and component link resolution key off.
+// linking and feature link resolution key off.
 async function updateProject(args) {
   return callZephlyAPI('mcpUpdateProject', args);
 }

package/handlers/tasks.js

@@ -4,8 +4,9 @@
  *
  * Project-First Hierarchy: Tasks belong to projects (required), with optional epic grouping
  *
- * Component assignment: Each task should belong to exactly one component.
- * AI agents must explicitly provide componentId (from get_current_project_context).
+ * Code links are derived: the files a task touches (changedFiles / linkedFiles)
+ * resolve to the features that own those paths (E-258). Agents name the feature
+ * the work advances through `links`.
  * Tags are auto-assigned based on content analysis against the local project cache.
  */
 
@@ -112,7 +113,7 @@ async function createTask(args) {
     }
   }
 
-  // Create the task (componentId should be explicitly provided by the agent)
+  // Create the task
   const result = await callZephlyAPI('mcpCreateTask', createArgs);
 
   // If the milestone is frozen and the operation was blocked, return guidance
@@ -159,7 +160,6 @@ async function createTask(args) {
       subjectType: 'task',
       subjectId: result.taskId,
       paths: (createArgs.linkedFiles || []).map((f) => f.path),
-      componentId: createArgs.componentId,
       epicId: createArgs.epicId,
     });
     const { autoLinked, linkSuggestions } = partitionProposals(proposals);
@@ -191,20 +191,6 @@ async function createTask(args) {
     }
   }
 
-  // If no component was named, include available components as a hint.
-  //
-  // Tests the EFFECTIVE set, not just the deprecated singular. Checking only
-  // `componentId` meant a create that correctly used `componentIds` was told it
-  // had named no component — while the links had in fact been written — so
-  // agents kept issuing a redundant follow-up update to fix nothing (#2429).
-  const namedComponents = Boolean(args.componentId)
-    || (Array.isArray(args.componentIds) && args.componentIds.some(Boolean));
-  if (!namedComponents && autoAssign?.availableComponents?.length) {
-    result.warning = 'Task created without a component. Please provide componentIds '
-      + 'for better organization. Use get_current_project_context() to see available components.';
-    result.availableComponents = autoAssign.availableComponents;
-  }
-
   // Attach create-time links (E-225) — best effort, never fails the create.
   await attachLinks(result, {
     sourceType: 'task',
@@ -282,7 +268,7 @@ function buildUntrackedDescription({ description, branch, changedFiles }) {
  * that would duplicate everything already created.
  */
 export async function bulkCreateTasks(args) {
-  const { projectId, epicId, componentId, componentIds, tasks = [] } = args;
+  const { projectId, epicId, tasks = [] } = args;
 
   if (!projectId) throw new Error('projectId is required');
   if (!Array.isArray(tasks) || tasks.length === 0) {
@@ -300,8 +286,6 @@ export async function bulkCreateTasks(args) {
   const result = await callZephlyAPI('mcpBulkCreateTasks', {
     projectId,
     epicId,
-    componentId,
-    componentIds,
     tasks: tasks.map(({ changedFiles, linkedFiles, ...rest }) => ({
       ...rest,
       // Accept the same two spellings as manage_task so callers do not have to
@@ -344,8 +328,6 @@ export async function reportUntrackedWork(args) {
     projectId,
     title,
     description,
-    componentId,
-    componentIds,
     origin = 'untracked',
     discoveredDuringTaskId,
     branch,
@@ -372,8 +354,6 @@ export async function reportUntrackedWork(args) {
     status: 'in_progress',
     origin,
     ...(discoveredDuringTaskId ? { discoveredDuringTaskId } : {}),
-    ...(componentId ? { componentId } : {}),
-    ...(Array.isArray(componentIds) && componentIds.length > 0 ? { componentIds } : {}),
     ...(epicId ? { epicId } : {}),
     ...(allLinks.length > 0 ? { links: allLinks } : {}),
     ...(Array.isArray(changedFiles) && changedFiles.length > 0
@@ -508,8 +488,8 @@ export async function getTask(args) {
 //
 // `files` has always been optional and callers routinely omit it, which costs
 // more than it looks: without paths the task is invisible to auto-linking
-// forever, since the engine has nothing to resolve against the component
-// inventory. Measured on saltpig, 359 of 1224 tasks carrying a commit had no
+// forever, since the engine has nothing to resolve against the paths features
+// own. Measured on saltpig, 359 of 1224 tasks carrying a commit had no
 // linked files at all.
 //
 // The fix is derivation rather than discipline. The commit SHA is already

package/lib/auto-assign.js

@@ -1,7 +1,7 @@
 /**
  * Auto-assign Utility
- * Matches task/epic content against cached tags and components
- * for automatic assignment during creation.
+ * Matches task/epic content against cached tags for automatic assignment
+ * during creation.
  */
 
 import { readConfig } from './local-cache.js';
@@ -13,20 +13,6 @@ function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-/**
- * Match components against text content using word boundary matching.
- * @param {string} text - Combined title + description
- * @param {Array} components - Array of {id, name, description}
- * @returns {Array} Matching component objects
- */
-export function matchComponents(text, components) {
-  if (!text || !components?.length) return [];
-  return components.filter((c) => {
-    const regex = new RegExp(`\\b${escapeRegex(c.name)}\\b`, 'i');
-    return regex.test(text);
-  });
-}
-
 /**
  * Match tags against text content using word boundary matching.
  * @param {string} text - Combined title + description
@@ -43,10 +29,7 @@ export function matchTags(text, tags) {
 
 /**
  * Resolve auto-assignment for a task being created.
- * Returns { matchedTags, availableComponents, organizationId } or null if no cache available.
- *
- * Components are NOT auto-assigned — agents must explicitly provide componentId.
- * This function returns available components so the handler can hint at them if needed.
+ * Returns { matchedTags, organizationId } or null if no cache available.
  *
  * @param {string} projectId - The task's project ID
  * @param {string} title - Task title
@@ -59,12 +42,10 @@ export async function resolveTaskAutoAssign(projectId, title, description) {
 
   const text = `${title || ''} ${description || ''}`.trim();
 
-  const components = config.projectId === projectId ? (config.components || []) : [];
   const tags = config.tags || [];
 
   return {
     matchedTags: text ? matchTags(text, tags) : [],
-    availableComponents: components.map((c) => ({ id: c.id, name: c.name })),
     organizationId: config.organizationId || null,
   };
 }

package/lib/autolink.js

@@ -3,7 +3,7 @@ import { callZephlyAPI } from './http-client.js';
 /**
  * Auto-linking helpers (E-225).
  *
- * The API resolves file paths to the components that own them and previews what
+ * The API resolves file paths to the features that own them and previews what
  * the autolink engine would propose. Both are read-only, so an agent can ask
  * "what does this touch?" before it creates or commits anything.
  *
@@ -14,27 +14,31 @@ import { callZephlyAPI } from './http-client.js';
  */
 
 /**
- * Resolve repo-relative file paths to the components that own them.
+ * Resolve repo-relative file paths to the features that own them through their
+ * code paths (E-258).
+ *
+ * The API's response may still carry a component `matches` array (components
+ * were retired after this server shipped); it is ignored.
  *
  * @param {object} params
  * @param {string} params.projectId
  * @param {string[]} params.paths - repo-relative paths
- * @returns {Promise<{matches: object[], unresolved: string[]}>}
+ * @returns {Promise<{features: object[], unresolved: string[]}>}
  */
-export async function resolvePathsToComponents({ projectId, paths }) {
+export async function resolvePathsToFeatures({ projectId, paths }) {
   if (!projectId || !Array.isArray(paths) || paths.length === 0) {
-    return { matches: [], unresolved: [] };
+    return { features: [], unresolved: [] };
   }
   try {
     const result = await callZephlyAPI('mcpResolvePaths', { projectId, paths });
     return {
-      matches: result?.matches || [],
+      features: result?.features || [],
       unresolved: result?.unresolved || [],
     };
   } catch {
     // An API predating E-225 has no such route. Report nothing rather than
     // surfacing a 404 the agent can do nothing about.
-    return { matches: [], unresolved: paths };
+    return { features: [], unresolved: paths };
   }
 }
 
@@ -50,7 +54,6 @@ export async function resolvePathsToComponents({ projectId, paths }) {
  * @param {string} params.subjectId
  * @param {string[]} [params.paths]
  * @param {string} [params.trigger]
- * @param {string} [params.componentId]
  * @param {string} [params.epicId]
  * @returns {Promise<{proposals: object[]}>}
  */
@@ -60,7 +63,6 @@ export async function previewEntityLinks({
   subjectId,
   paths,
   trigger,
-  componentId,
   epicId,
 }) {
   if (!subjectType || !subjectId) return { proposals: [] };
@@ -71,7 +73,6 @@ export async function previewEntityLinks({
       subjectId,
       paths,
       trigger,
-      componentId,
       epicId,
     });
     return { proposals: result?.proposals || [] };

package/lib/instructions.generated.js

@@ -9,6 +9,6 @@
  * __tests__/instructions.test.js fails if this drifts from the skill.
  */
 
-export const WORK_TRACKING_CORE = 'Work in this repository is tracked in EzModo, and the tools for it are on this\nMCP server. The contract, in short:\n\n1. **Create the task before you edit, not after.** A task written afterwards is\n   a changelog; a task written first is what the next session reads to find out\n   what you were doing and why.\n2. **Start the session by calling `get_current_project_context()`.** Cache the\n   `projectId`. It also returns the components, tags and `terminology` you need.\n   No `.ezmodo/config.json` means this repo is not tracked — say so rather than\n   guessing at a project.\n3. **Call `get_context` with a keyword query before creating anything.** Use\n   what comes back to write a task that names real files, endpoints and\n   patterns. A vague task is not worth the call that made it.\n4. **Name every component the work touches** via `componentIds`. A task spanning\n   web and api belongs to both. The list REPLACES the previous set on update.\n5. **Set `taskType`** — `feature` | `bug` | `testing` | `chore`. Not cosmetic:\n   `bug` feeds open-bug counts, milestone freezes gate on it, and estimation\n   weights past tasks of the same kind.\n6. **Toggle steps as you finish them**, not in a batch at the end\n   (`manage_task action:"update" toggleSteps:[...]`).\n7. **Capture knowledge the moment it happens**, not in a summary at the end:\n   `addKnowledge` with `fact` for a root cause, `decision` for a choice —\n   including what you rejected and why — `reference` for a key file or pattern,\n   `context` for progress. Be specific: file paths, function names, exact\n   errors. "Fixed a bug in the parser" helps nobody.\n8. **Already three edits in with no task?** Call `report_untracked_work` the\n   moment you notice, rather than continuing untracked.\n9. **Resuming?** `get_task` first, and read ALL of its knowledge items. That is\n   where the previous session\'s reasoning went — do not re-derive it.\n10. **Finish at `in_review`** with `completionNotes`, and do NOT call\n    `action:"complete"`. A human completes a task after verifying it.\n11. **Report what actually happened.** A task moved to `in_review` claiming work\n    that was not done is worse than no task, because the next session trusts it.\n\nRespect the project\'s `terminology`: a project can rename epics, tasks and\ncomponents, and a marketing project calls an epic a "Campaign". Write anything a\nhuman reads in those words; keep API field names (`epicId`, `taskId`) as they\nare.';
+export const WORK_TRACKING_CORE = "Work in this repository is tracked in EzModo, and the tools for it are on this\nMCP server. The contract, in short:\n\n1. **Create the task before you edit, not after.** A task written afterwards is\n   a changelog; a task written first is what the next session reads to find out\n   what you were doing and why.\n2. **Start the session by calling `get_current_project_context()`.** Cache the\n   `projectId`. It also returns the tags and `terminology` you need.\n   No `.ezmodo/config.json` means this repo is not tracked — say so rather than\n   guessing at a project.\n3. **Call `get_context` with a keyword query before creating anything.** Use\n   what comes back to write a task that names real files, endpoints and\n   patterns. A vague task is not worth the call that made it.\n4. **Link the feature the work advances** via `links: [{targetType:\"feature\",\n   targetId}]`, found with `search_features`. Code links are derived: features\n   own code paths, and the files you touch link the work to their owners.\n5. **Set `taskType`** — `feature` | `bug` | `testing` | `chore`. Not cosmetic:\n   `bug` feeds open-bug counts, milestone freezes gate on it, and estimation\n   weights past tasks of the same kind.\n6. **Toggle steps as you finish them**, not in a batch at the end\n   (`manage_task action:\"update\" toggleSteps:[...]`).\n7. **Capture knowledge the moment it happens**, not in a summary at the end:\n   `addKnowledge` with `fact` for a root cause, `decision` for a choice —\n   including what you rejected and why — `reference` for a key file or pattern,\n   `context` for progress. Be specific: file paths, function names, exact\n   errors. \"Fixed a bug in the parser\" helps nobody.\n8. **Already three edits in with no task?** Call `report_untracked_work` the\n   moment you notice, rather than continuing untracked.\n9. **Resuming?** `get_task` first, and read ALL of its knowledge items. That is\n   where the previous session's reasoning went — do not re-derive it.\n10. **Finish at `in_review`** with `completionNotes`, and do NOT call\n    `action:\"complete\"`. A human completes a task after verifying it.\n11. **Report what actually happened.** A task moved to `in_review` claiming work\n    that was not done is worse than no task, because the next session trusts it.\n\nRespect the project's `terminology`: a project can rename epics and tasks, and a\nmarketing project calls an epic a \"Campaign\". Write anything a\nhuman reads in those words; keep API field names (`epicId`, `taskId`) as they\nare.";
 
-export const WORK_TRACKING_LOCAL = 'Running against a local checkout, two more:\n\n12. **Link every commit**: `manage_task action:"link_commit"` with the full\n    40-character `sha` from `git rev-parse HEAD`. A short SHA is rejected, and\n    padding one is not a fix. Linking is also what derives component links from\n    the commit\'s files — do not link those by hand.\n13. **Pass `changedFiles`** when creating or updating a task, so the work\n    resolves to the components that own those paths.';
+export const WORK_TRACKING_LOCAL = "Running against a local checkout, two more:\n\n12. **Link every commit**: `manage_task action:\"link_commit\"` with the full\n    40-character `sha` from `git rev-parse HEAD`. A short SHA is rejected, and\n    padding one is not a fix. Linking is also what derives feature links from\n    the commit's files — do not link those by hand.\n13. **Pass `changedFiles`** when creating or updating a task, so the work\n    resolves to the features that own those paths.";