@ezmodo/mcp-server 0.14.4 → 0.18.0

package/config/endpoint-map.js

@@ -29,6 +29,11 @@ export const ENDPOINT_MAP = {
   'mcpSearchEpics': { route: 'mcp/v1/epics/search', method: 'POST' },
   'mcpListEpics': { route: 'mcp/v1/epics', method: 'GET' },
   'mcpGetEpic': { route: 'mcp/v1/epics/by-id', method: 'GET' },
+  // E-259: epic plan with revisions.
+  'mcpGetEpicPlan': { route: 'mcp/v1/epics/plan', method: 'GET' },
+  'mcpUpdateEpicPlan': { route: 'mcp/v1/epics/plan', method: 'PUT' },
+  'mcpListEpicComments': { route: 'mcp/v1/epics/comments', method: 'GET' },
+  'mcpAddEpicComment': { route: 'mcp/v1/epics/comments', method: 'POST' },
   // E-237 #2382: the epic is the fifth consumer of the grounding engine.
   'mcpGenerateEpicHowItWorks': { route: 'mcp/v1/epics/generate-how-it-works', method: 'POST' },
   'mcpApplyEpicHowItWorks': { route: 'mcp/v1/epics/apply-how-it-works', method: 'POST' },
@@ -131,27 +136,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 +195,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' },
@@ -228,6 +214,11 @@ export const ENDPOINT_MAP = {
   'mcpPromoteDecisionFromKnowledge': { route: 'mcp/v1/decisions/promote-from-knowledge', method: 'POST' },
   'mcpLinkDecisionArtifact': { route: 'mcp/v1/decisions/link', method: 'POST' },
   'mcpUnlinkDecisionArtifact': { route: 'mcp/v1/decisions/link', method: 'DELETE' },
+  // Decisions to make on an epic (E-259).
+  'mcpAddDecisionInput': { route: 'mcp/v1/decisions/inputs', method: 'POST' },
+  'mcpDecideDecision': { route: 'mcp/v1/decisions/decide', method: 'POST' },
+  'mcpHoldTaskForDecision': { route: 'mcp/v1/decisions/holds', method: 'POST' },
+  'mcpReleaseTaskFromDecision': { route: 'mcp/v1/decisions/holds', method: 'DELETE' },
 
   // Recurring task schedules (E-211) — "what task to create, on what cadence".
   'mcpCreateRecurringTask': { route: 'mcp/v1/recurring-tasks', method: 'POST' },
@@ -270,6 +261,13 @@ 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' },
+  'mcpListUnmappedPaths': { route: 'mcp/v1/unmapped-paths', method: 'GET' },
+  'mcpAssignUnmappedPath': { route: 'mcp/v1/unmapped-paths/assign', method: 'POST' },
+  'mcpDismissUnmappedPath': { route: 'mcp/v1/unmapped-paths/dismiss', method: 'POST' },
+  'mcpReconcileUnmappedPaths': { route: 'mcp/v1/unmapped-paths/reconcile', 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/decisions.js

@@ -25,8 +25,13 @@ export async function manageDecision(args) {
   case 'unlink': return unlinkDecisionArtifact(params);
   case 'supersede': return supersedeDecision(params);
   case 'promote_from_knowledge': return promoteFromKnowledge(params);
+  case 'add_input': return addDecisionInput(params);
+  case 'decide': return decideDecision(params);
+  case 'hold_task': return holdTask(params);
+  case 'release_task': return releaseTask(params);
   default:
-    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, supersede, or promote_from_knowledge.`);
+    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, ` +
+      'supersede, promote_from_knowledge, add_input, decide, hold_task, or release_task.');
   }
 }
 
@@ -48,6 +53,13 @@ export async function getDecision(args) {
     return result;
   }
 
+  // Decisions to make on an epic (E-259).
+  if (filters.epicId) {
+    const params = { epicId: filters.epicId };
+    if (filters.status) params.status = filters.status;
+    return callZephlyAPI('mcpListDecisions', params);
+  }
+
   // List mode
   const params = {};
   if (organizationId) params.organizationId = organizationId;
@@ -66,6 +78,10 @@ export async function getDecision(args) {
 async function createDecision(args) {
   // `links` is applied by the MCP layer after the decision exists (E-225).
   const { links, ...createArgs } = args;
+  // On create the server takes option labels; accept {label} objects too.
+  if (Array.isArray(createArgs.choices)) {
+    createArgs.choices = createArgs.choices.map((c) => (typeof c === 'string' ? c : c?.label));
+  }
   const result = await callZephlyAPI('mcpCreateDecision', createArgs);
 
   // Attach create-time links (E-225) — best effort, never fails the create.
@@ -79,6 +95,11 @@ async function createDecision(args) {
 }
 
 async function updateDecision(args) {
+  // On update the server takes the full list as {id, label}; a bare string is
+  // a new option.
+  if (Array.isArray(args.choices)) {
+    args = { ...args, choices: args.choices.map((c) => (typeof c === 'string' ? { label: c } : c)) };
+  }
   return callZephlyAPI('mcpUpdateDecision', args);
 }
 
@@ -112,3 +133,24 @@ async function promoteFromKnowledge({ organizationId, taskId, knowledgeId, title
     linkToId,
   });
 }
+
+// --- Decisions to make on an epic (E-259) ---
+
+// Record a pick. It counts for the person whose key is used, and replaces
+// their earlier pick; the server records which AI made it.
+async function addDecisionInput({ decisionId, choiceId, reason }) {
+  return callZephlyAPI('mcpAddDecisionInput', { decisionId, choiceId, reason });
+}
+
+// Decide. The server refuses anyone but the epic's owner or an editor.
+async function decideDecision({ decisionId, status, choiceId, decision, rejectedReasons }) {
+  return callZephlyAPI('mcpDecideDecision', { decisionId, status, choiceId, decision, rejectedReasons });
+}
+
+async function holdTask({ decisionId, taskId }) {
+  return callZephlyAPI('mcpHoldTaskForDecision', { decisionId, taskId });
+}
+
+async function releaseTask({ decisionId, taskId }) {
+  return callZephlyAPI('mcpReleaseTaskFromDecision', { decisionId, taskId });
+}

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.
@@ -188,3 +188,51 @@ export async function getEpic(args) {
   if (webUrl && result?.epic) result.epic.webUrl = webUrl;
   return result;
 }
+
+/**
+ * Read an epic's plan with its current revision (E-259).
+ */
+export async function getEpicPlan(args) {
+  return callZephlyAPI('mcpGetEpicPlan', args);
+}
+
+/**
+ * Save an epic's plan against the revision it was read at (E-259). A conflict
+ * is returned as a result, not thrown: it is an expected outcome when several
+ * people's AIs share a plan, and the agent needs the current plan and what
+ * changed to redo its edit.
+ */
+export async function updateEpicPlan(args) {
+  try {
+    return await callZephlyAPI('mcpUpdateEpicPlan', args);
+  } catch (err) {
+    if (err?.code === 'PLAN_CONFLICT') {
+      const details = err.details || {};
+      return {
+        saved: false,
+        conflict: true,
+        message: `Someone else changed this plan since revision ${details.baseRevision}. ` +
+          'Nothing was saved. Apply your change to the current plan below and save again with ' +
+          `baseRevision ${details.currentRevision}. Do not resend your old copy.`,
+        currentRevision: details.currentRevision,
+        changesSince: details.changesSince || [],
+        currentPlan: details.current || null,
+      };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Read an epic's discussion (E-259).
+ */
+export async function listEpicComments(args) {
+  return callZephlyAPI('mcpListEpicComments', args);
+}
+
+/**
+ * Post to an epic's discussion, or reply in a thread (E-259).
+ */
+export async function addEpicComment(args) {
+  return callZephlyAPI('mcpAddEpicComment', args);
+}

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,12 +9,12 @@
 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';
 import * as designHandlers from './designs.js';
 import * as catalogHandlers from './catalogs.js';
+import * as unmappedPathHandlers from './unmapped-paths.js';
 import * as featureFlagHandlers from './feature-flags.js';
 import * as taskHandlers from './tasks.js';
 import * as documentHandlers from './documents.js';
@@ -59,10 +59,10 @@ export const HANDLERS = {
   search_epics: epicHandlers.searchEpics,
   list_epics: epicHandlers.listEpics,
   get_epic: epicHandlers.getEpic,
-
-  // Components
-  manage_component: componentHandlers.manageComponent,
-  list_components: componentHandlers.listComponents,
+  get_epic_plan: epicHandlers.getEpicPlan,
+  update_epic_plan: epicHandlers.updateEpicPlan,
+  list_epic_comments: epicHandlers.listEpicComments,
+  add_epic_comment: epicHandlers.addEpicComment,
 
   // Milestones
   manage_milestone: milestoneHandlers.manageMilestone,
@@ -91,6 +91,8 @@ export const HANDLERS = {
   manage_catalog: catalogHandlers.manageCatalog,
   get_catalog: catalogHandlers.getCatalog,
   list_catalogs: catalogHandlers.listCatalogs,
+  list_unmapped_paths: unmappedPathHandlers.listUnmappedPaths,
+  resolve_unmapped: unmappedPathHandlers.resolveUnmapped,
   list_catalog_items: catalogHandlers.listCatalogItems,
   get_catalog_diff: catalogHandlers.getCatalogDiff,
 

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