@meltstudio/meltctl 4.154.2 → 4.155.0

package/dist/index.js

@@ -14,7 +14,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
-    CLI_VERSION = "4.154.2";
+    CLI_VERSION = "4.155.0";
   }
 });
 
@@ -663,6 +663,8 @@ function createProjectsResource(config) {
       const params = new URLSearchParams();
       if (opts?.activeOnly)
         params.set("activeOnly", "true");
+      if (opts?.includeInternal)
+        params.set("includeInternal", "true");
       const path9 = `/projects${params.toString() ? `?${params}` : ""}`;
       const { data, status } = await apiFetch(config, path9);
       if (status === 403)
@@ -942,8 +944,19 @@ function unwrap(label, response, okStatus = 200) {
 function createPmResource(config) {
   return {
     // ─── Features ─────────────────────────────────────────────────────────
-    async listFeatures(projectId) {
-      const res = await apiFetch(config, `/pm/features?projectId=${projectId}`);
+    async listFeatures(projectId, filters) {
+      const params = new URLSearchParams({ projectId: String(projectId) });
+      if (filters?.phaseId)
+        params.set("phaseId", filters.phaseId);
+      if (filters?.status)
+        params.set("status", filters.status);
+      if (filters?.category)
+        params.set("category", filters.category);
+      if (filters?.currentStage)
+        params.set("currentStage", filters.currentStage);
+      if (filters?.targetStage)
+        params.set("targetStage", filters.targetStage);
+      const res = await apiFetch(config, `/pm/features?${params}`);
       return unwrap("list features", res);
     },
     async getFeature(id) {
@@ -953,10 +966,28 @@ function createPmResource(config) {
     async createFeature(input3) {
       const res = await apiFetch(config, `/pm/features`, {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeCreateFeatureInput(input3))
       });
       return unwrap("create feature", res, 201);
     },
+    /**
+     * Bulk feature create — accepts an array of inputs and returns one
+     * result per item with `success: true | false` so partial failures
+     * don't sink the whole batch. Each item is wrapped in its own
+     * transaction (feature + phase memberships if any). Built for
+     * one-shot migrations of an existing roadmap into meltctl.
+     *
+     * Status code: 201 when every item succeeded; 207 (multi-status)
+     * when at least one failed. The unwrap layer accepts both.
+     */
+    async createFeaturesBatch(inputs) {
+      const res = await apiFetch(config, `/pm/features/batch`, {
+        method: "POST",
+        body: JSON.stringify({ features: inputs.map(normalizeCreateFeatureInput) })
+      });
+      const body = unwrap("create features batch", res, [201, 207]);
+      return body.results;
+    },
     async updateFeature(id, input3) {
       const res = await apiFetch(config, `/pm/features/${id}`, {
         method: "PATCH",
@@ -985,14 +1016,23 @@ function createPmResource(config) {
     async createPhase(input3) {
       const res = await apiFetch(config, `/pm/phases`, {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeCreatePhaseInput(input3))
       });
       return unwrap("create phase", res, 201);
     },
+    /** Bulk phase create — same shape as createFeaturesBatch. */
+    async createPhasesBatch(inputs) {
+      const res = await apiFetch(config, `/pm/phases/batch`, {
+        method: "POST",
+        body: JSON.stringify({ phases: inputs.map(normalizeCreatePhaseInput) })
+      });
+      const body = unwrap("create phases batch", res, [201, 207]);
+      return body.results;
+    },
     async updatePhase(id, input3) {
       const res = await apiFetch(config, `/pm/phases/${id}`, {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeUpdatePhaseInput(input3))
       });
       return unwrap("update phase", res);
     },
@@ -1132,6 +1172,31 @@ function createPmResource(config) {
     }
   };
 }
+function toIsoOrNull(value) {
+  if (value === void 0)
+    return void 0;
+  if (value === null)
+    return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeCreateFeatureInput(input3) {
+  if (input3.createdAt === void 0)
+    return input3;
+  return { ...input3, createdAt: toIsoOrNull(input3.createdAt) ?? void 0 };
+}
+function normalizeCreatePhaseInput(input3) {
+  const out = { ...input3 };
+  if (input3.createdAt !== void 0)
+    out.createdAt = toIsoOrNull(input3.createdAt) ?? void 0;
+  if (input3.closedAt !== void 0)
+    out.closedAt = toIsoOrNull(input3.closedAt);
+  return out;
+}
+function normalizeUpdatePhaseInput(input3) {
+  if (input3.closedAt === void 0)
+    return input3;
+  return { ...input3, closedAt: toIsoOrNull(input3.closedAt) };
+}
 
 // ../sdk/dist/resources/slack.js
 function createSlackResource(config) {
@@ -3535,6 +3600,8 @@ function createProjectsResource2(config) {
       const params = new URLSearchParams();
       if (opts?.activeOnly)
         params.set("activeOnly", "true");
+      if (opts?.includeInternal)
+        params.set("includeInternal", "true");
       const path22 = `/projects${params.toString() ? `?${params}` : ""}`;
       const { data, status } = await apiFetch2(config, path22);
       if (status === 403)
@@ -3806,8 +3873,19 @@ function unwrap2(label, response, okStatus = 200) {
 function createPmResource2(config) {
   return {
     // ─── Features ─────────────────────────────────────────────────────────
-    async listFeatures(projectId) {
-      const res = await apiFetch2(config, `/pm/features?projectId=${projectId}`);
+    async listFeatures(projectId, filters) {
+      const params = new URLSearchParams({ projectId: String(projectId) });
+      if (filters?.phaseId)
+        params.set("phaseId", filters.phaseId);
+      if (filters?.status)
+        params.set("status", filters.status);
+      if (filters?.category)
+        params.set("category", filters.category);
+      if (filters?.currentStage)
+        params.set("currentStage", filters.currentStage);
+      if (filters?.targetStage)
+        params.set("targetStage", filters.targetStage);
+      const res = await apiFetch2(config, `/pm/features?${params}`);
       return unwrap2("list features", res);
     },
     async getFeature(id) {
@@ -3817,10 +3895,28 @@ function createPmResource2(config) {
     async createFeature(input3) {
       const res = await apiFetch2(config, `/pm/features`, {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeCreateFeatureInput2(input3))
       });
       return unwrap2("create feature", res, 201);
     },
+    /**
+     * Bulk feature create — accepts an array of inputs and returns one
+     * result per item with `success: true | false` so partial failures
+     * don't sink the whole batch. Each item is wrapped in its own
+     * transaction (feature + phase memberships if any). Built for
+     * one-shot migrations of an existing roadmap into meltctl.
+     *
+     * Status code: 201 when every item succeeded; 207 (multi-status)
+     * when at least one failed. The unwrap layer accepts both.
+     */
+    async createFeaturesBatch(inputs) {
+      const res = await apiFetch2(config, `/pm/features/batch`, {
+        method: "POST",
+        body: JSON.stringify({ features: inputs.map(normalizeCreateFeatureInput2) })
+      });
+      const body = unwrap2("create features batch", res, [201, 207]);
+      return body.results;
+    },
     async updateFeature(id, input3) {
       const res = await apiFetch2(config, `/pm/features/${id}`, {
         method: "PATCH",
@@ -3849,14 +3945,23 @@ function createPmResource2(config) {
     async createPhase(input3) {
       const res = await apiFetch2(config, `/pm/phases`, {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeCreatePhaseInput2(input3))
       });
       return unwrap2("create phase", res, 201);
     },
+    /** Bulk phase create — same shape as createFeaturesBatch. */
+    async createPhasesBatch(inputs) {
+      const res = await apiFetch2(config, `/pm/phases/batch`, {
+        method: "POST",
+        body: JSON.stringify({ phases: inputs.map(normalizeCreatePhaseInput2) })
+      });
+      const body = unwrap2("create phases batch", res, [201, 207]);
+      return body.results;
+    },
     async updatePhase(id, input3) {
       const res = await apiFetch2(config, `/pm/phases/${id}`, {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(normalizeUpdatePhaseInput2(input3))
       });
       return unwrap2("update phase", res);
     },
@@ -3996,6 +4101,31 @@ function createPmResource2(config) {
     }
   };
 }
+function toIsoOrNull2(value) {
+  if (value === void 0)
+    return void 0;
+  if (value === null)
+    return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeCreateFeatureInput2(input3) {
+  if (input3.createdAt === void 0)
+    return input3;
+  return { ...input3, createdAt: toIsoOrNull2(input3.createdAt) ?? void 0 };
+}
+function normalizeCreatePhaseInput2(input3) {
+  const out = { ...input3 };
+  if (input3.createdAt !== void 0)
+    out.createdAt = toIsoOrNull2(input3.createdAt) ?? void 0;
+  if (input3.closedAt !== void 0)
+    out.closedAt = toIsoOrNull2(input3.closedAt);
+  return out;
+}
+function normalizeUpdatePhaseInput2(input3) {
+  if (input3.closedAt === void 0)
+    return input3;
+  return { ...input3, closedAt: toIsoOrNull2(input3.closedAt) };
+}
 function createSlackResource2(config) {
   return {
     async listChannels() {
@@ -4560,36 +4690,88 @@ function withClientArgs(getClient2, handler) {
     }
   };
 }
-async function listProjects(client) {
-  return safe(() => client.projects.list({ activeOnly: true }));
+async function listProjects(client, input3) {
+  const hasPM = input3.hasPM ?? true;
+  const includeInternal = input3.includeInternal ?? false;
+  return safe(() => client.projects.list({ activeOnly: hasPM, includeInternal }));
 }
 async function getProjectSettings(client, input3) {
   return safe(() => client.pm.getProjectSettings(input3.projectId));
 }
+async function updateProjectSettings(client, input3) {
+  const { projectId, ...patch } = input3;
+  return safe(
+    () => client.pm.updateProjectSettings(projectId, patch)
+  );
+}
 async function getProjectContext(client, input3) {
   return safe(() => client.pm.getProjectContext(input3.projectId));
 }
+var PROJECT_STAGE_VALUES = ["prototype", "early_revenue", "growth", "scale"];
 function registerProjectTools(server, getClient2) {
   server.registerTool(
     "list_projects",
     {
       title: "List projects",
-      description: "Lists every actively-managed Melt project the authenticated user can see \u2014 i.e. projects with a project manager assigned. Use this to resolve a project's name to its numeric `projectId` before calling any other tool. Returns id, name, client, project manager, and repo count per project. Projects without a PM are unmanaged and intentionally excluded; create_feature / assign_feature_to_phase against an unmanaged project will succeed but is rarely intended.",
-      inputSchema: {}
+      description: "Lists Melt projects the authenticated user can see. Defaults: hasPM=true (only actively-managed projects), includeInternal=false (Melt's own internal projects hidden). Use this to resolve a project's name to its numeric `projectId` before calling any other tool. Returns id, name, client, project manager, and repo count per project.",
+      inputSchema: {
+        hasPM: z22.boolean().optional().describe(
+          "Default true. When true, only projects with a project manager assigned are returned (recommended for AI agent flows). Set false to include unmanaged projects."
+        ),
+        includeInternal: z22.boolean().optional().describe(
+          "Default false. When false, Melt's own internal projects are hidden. Set true to include them."
+        )
+      }
     },
-    withClient(getClient2, listProjects)
+    withClientArgs(getClient2, listProjects)
   );
   server.registerTool(
     "get_project_settings",
     {
       title: "Get project settings",
-      description: "Returns the project's PM-skills settings: cadence (weekly/biweekly/monthly), start_day, demo_day, team_size, velocity_override, Linear workspace, Notion URLs, code repo path, tech-support contact, default language, project glossary. Returns sensible defaults if no settings row exists yet (cadence=weekly, start_day=Monday, demo_day=Friday, defaultLanguage=English).",
+      description: 'Returns the project\'s PM-skills settings: cadence (weekly/biweekly/monthly), start_day, demo_day, team_size, velocity_override, Linear workspace, Notion URLs, code repo path, tech-support contact, default language, project glossary, project stage. Includes a `warnings` array flagging settings whose absence breaks downstream behavior (e.g., "calculator: missing teamSize"). Returns sensible defaults if no settings row exists yet (cadence=weekly, start_day=Monday, demo_day=Friday, defaultLanguage=English).',
       inputSchema: {
         projectId: z22.number().int().positive().describe("Strapi project id from list_projects.")
       }
     },
     withClientArgs(getClient2, getProjectSettings)
   );
+  server.registerTool(
+    "update_project_settings",
+    {
+      title: "Update project settings",
+      description: "Patches PM-skills settings for a project. Pass only the fields you want to change. Use cases: setting teamSize after a roadmap migration so the maturity-jumps calculator renders, setting projectStage so audit calibration uses the right baseline, wiring notionProjectProfileUrl so risks/feedback route to the right Notion page. The PM should review the proposed change before this is called \u2014 this is a write operation. Pass null to clear a nullable field.",
+      inputSchema: {
+        projectId: z22.number().int().positive().describe("Strapi project id from list_projects."),
+        cadence: z22.enum(["weekly", "biweekly", "monthly"]).optional().describe("Sprint cadence."),
+        startDay: z22.string().min(1).optional().describe('Sprint start day, e.g. "Monday".'),
+        demoDay: z22.string().min(1).optional().describe('Demo day, e.g. "Friday".'),
+        teamSize: z22.number().int().nonnegative().nullable().optional().describe(
+          "Active developer count for the maturity-jumps calculator. Pass null to clear (calculator falls back to 1)."
+        ),
+        velocityOverride: z22.number().positive().nullable().optional().describe(
+          "Project-specific velocity override (stories/week/dev). Wins over the company baseline when set. Pass null to clear."
+        ),
+        linearWorkspace: z22.string().nullable().optional().describe('Linear workspace slug, e.g. "meltstudio". Pass null to clear.'),
+        notionCallLogUrl: z22.string().url().nullable().optional().describe("Notion URL for the team's call log. Pass null to clear."),
+        notionProjectProfileUrl: z22.string().url().nullable().optional().describe(
+          "Notion URL for the project profile page (Risks + Feedback sections live there). Required for intake routing of risks/feedback. Pass null to clear."
+        ),
+        codeRepoPath: z22.string().nullable().optional().describe(
+          "Local path to the project's code repo. When set, intake skills can investigate code inline; when null, they create tech-investigation requests instead."
+        ),
+        techSupportContact: z22.string().nullable().optional().describe("Email or handle of the project's tech-support contact. Pass null to clear."),
+        defaultLanguage: z22.string().min(1).optional().describe("Default language for client-facing artifacts (recap emails, etc)."),
+        projectGlossary: z22.string().nullable().optional().describe(
+          "Free-text project glossary surfaced to skills as context. Pass null to clear."
+        ),
+        projectStage: z22.enum(PROJECT_STAGE_VALUES).nullable().optional().describe(
+          "Canonical PM-owned project stage that drives audit calibration: prototype | early_revenue | growth | scale. The server stamps projectStageSetBy + projectStageSetAt automatically. Pass null to clear."
+        )
+      }
+    },
+    withClientArgs(getClient2, updateProjectSettings)
+  );
   server.registerTool(
     "get_project_context",
     {
@@ -4602,19 +4784,26 @@ function registerProjectTools(server, getClient2) {
     withClientArgs(getClient2, getProjectContext)
   );
 }
+var SHAPE_VALUES = ["crawling", "walking", "running"];
 var SHAPE_DESC = "crawling | walking | running. Target shape is intent (PM sets when creating); current shape is computed from feature stages.";
 async function listPhases(client, input3) {
   return safe(() => client.pm.listPhases(input3.projectId, input3.includeClosed ?? false));
 }
 async function createPhase(client, input3) {
-  return safe(
-    () => client.pm.createPhase({
-      projectId: input3.projectId,
-      name: input3.name,
-      targetShape: input3.targetShape,
-      ...input3.isPrimary !== void 0 ? { isPrimary: input3.isPrimary } : {}
-    })
-  );
+  return safe(() => client.pm.createPhase(input3));
+}
+async function createPhasesBatch(client, input3) {
+  return safe(() => client.pm.createPhasesBatch(input3.phases));
+}
+async function updatePhase(client, input3) {
+  const { id, ...patch } = input3;
+  return safe(() => client.pm.updatePhase(id, patch));
+}
+async function deletePhase(client, input3) {
+  return safe(async () => {
+    await client.pm.deletePhase(input3.id);
+    return { ok: true, id: input3.id };
+  });
 }
 async function assignFeatureToPhase(client, input3) {
   return safe(() => client.pm.assignFeature(input3.phaseId, input3.featureId));
@@ -4625,8 +4814,10 @@ async function unassignFeatureFromPhase(client, input3) {
 var createPhaseInputSchema = z3.object({
   projectId: z3.number().int().positive(),
   name: z3.string().min(1),
-  targetShape: z3.enum(["crawling", "walking", "running"]).default("walking"),
-  isPrimary: z3.boolean().optional()
+  targetShape: z3.enum(SHAPE_VALUES).default("walking"),
+  isPrimary: z3.boolean().optional(),
+  createdAt: z3.string().datetime().optional(),
+  closedAt: z3.string().datetime().nullable().optional()
 });
 function registerPhaseTools(server, getClient2) {
   server.registerTool(
@@ -4645,18 +4836,74 @@ function registerPhaseTools(server, getClient2) {
     "create_phase",
     {
       title: "Create phase",
-      description: "Creates a new phase on the project. The PM should review the proposed name + target shape before this is called \u2014 this is a write operation. If isPrimary=true, any existing primary phase on the project is automatically demoted (atomic). Use isPrimary sparingly; multi-active phases without changing primary is the safer default.",
+      description: "Creates a new phase on the project. The PM should review the proposed name + target shape before this is called \u2014 this is a write operation. If isPrimary=true, any existing primary phase on the project is automatically demoted (atomic). Use isPrimary sparingly; multi-active phases without changing primary is the safer default. For roadmap migrations preserving historical timelines, pass createdAt and/or closedAt \u2014 a non-null closedAt also marks the phase isActive=false + isPrimary=false.",
       inputSchema: {
         projectId: z3.number().int().positive(),
         name: z3.string().min(1).describe('e.g. "MVP launch", "V2 features".'),
-        targetShape: z3.enum(["crawling", "walking", "running"]).default("walking").describe(SHAPE_DESC),
+        targetShape: z3.enum(SHAPE_VALUES).default("walking").describe(SHAPE_DESC),
         isPrimary: z3.boolean().optional().describe(
           "Default false. Setting true demotes any existing primary phase. Only one primary per project."
+        ),
+        createdAt: z3.string().datetime().optional().describe(
+          "ISO 8601 timestamp. Backdates createdAt \u2014 only set this when migrating an existing phase that has a real historical creation date."
+        ),
+        closedAt: z3.string().datetime().nullable().optional().describe(
+          "ISO 8601 timestamp. When set, the phase is created as historical (isActive=false, isPrimary=false). Use to backfill phases that closed months ago."
         )
       }
     },
     withClientArgs(getClient2, createPhase)
   );
+  server.registerTool(
+    "create_phases_batch",
+    {
+      title: "Create phases batch",
+      description: "Bulk phase create \u2014 accepts an array of inputs (max 100) and returns one result per input with success or error. Each item is wrapped in its own transaction. Built for one-shot migrations of an existing roadmap.",
+      inputSchema: {
+        phases: z3.array(createPhaseInputSchema).min(1).max(100).describe("Up to 100 phase inputs. Each accepts the same fields as create_phase.")
+      }
+    },
+    withClientArgs(getClient2, createPhasesBatch)
+  );
+  server.registerTool(
+    "update_phase",
+    {
+      title: "Update phase",
+      description: "Patches fields on an existing phase. Pass only the fields you want to change. Common uses: rename, switch target shape, override or clear the computed current shape, set or clear primary, mark a phase closed/reopened. The PM should review the proposed change before this is called \u2014 this is a write operation. Setting closedAt non-null forces isActive=false + isPrimary=false; setting isActive=false also clears isPrimary.",
+      inputSchema: {
+        id: z3.string().uuid().describe("Phase id from list_phases or create_phase."),
+        name: z3.string().min(1).optional(),
+        targetShape: z3.enum(SHAPE_VALUES).optional().describe(SHAPE_DESC),
+        currentShapeOverride: z3.enum(SHAPE_VALUES).nullable().optional().describe(
+          "Force the phase's current shape regardless of feature distribution. Pass null to clear and resume computed-shape behavior."
+        ),
+        overrideReason: z3.string().nullable().optional().describe("Free-text reason for the shape override. Pass null to clear."),
+        isPrimary: z3.boolean().optional().describe(
+          "Promote this phase to primary. Server demotes any existing primary atomically."
+        ),
+        isActive: z3.boolean().optional().describe(
+          "Set to false to deactivate (also clears isPrimary). Set to true to reopen a closed phase (closedAt stays unless you also clear it)."
+        ),
+        closedAt: z3.string().datetime().nullable().optional().describe(
+          "ISO 8601 timestamp or null. When set non-null, forces isActive=false + isPrimary=false. When null, clears the closed-at stamp."
+        )
+      }
+    },
+    withClientArgs(getClient2, updatePhase)
+  );
+  server.registerTool(
+    "delete_phase",
+    {
+      title: "Delete phase (DESTRUCTIVE \u2014 hard delete, no undo)",
+      description: `\u26A0 DESTRUCTIVE. Hard-deletes the phase row from postgres. Not a soft archive \u2014 the row is gone and there is no recovery short of restoring the database from backup. The API refuses the delete if the phase still has features assigned (move or unassign the features first); this safety net prevents accidentally cascading away every phase membership in one call. Use ONLY for rolling back a bad insert during a migration or removing a phase created in error.
+
+Mandatory caller behavior: present the phase's name + id + active/closed status + the count of any current feature memberships to the PM, get explicit confirmation ("yes, delete <name>"), then call. Never call without that confirmation. If you have any doubt, prefer closing the phase via update_phase (closedAt + isActive=false) instead \u2014 that preserves history.`,
+      inputSchema: {
+        id: z3.string().uuid().describe("Phase id from list_phases or create_phase.")
+      }
+    },
+    withClientArgs(getClient2, deletePhase)
+  );
   server.registerTool(
     "assign_feature_to_phase",
     {
@@ -4686,11 +4933,21 @@ var STAGE_VALUES = ["idea", "poc", "pt", "mv", "mk", "ma", "mbi"];
 var STAGE_DESC = "idea | poc | pt | mv | mk | ma | mbi. The 7 maturity stages from the workflow doc \u2014 pick the one that matches where the work *looks like* it is right now (or where it should land for target).";
 var PRD_PATH_DESC = "http(s) URL pointing to the PRD (Notion, Google Doc, etc.). Omit if there is no PRD yet \u2014 relative paths or plain text are rejected.";
 async function listFeatures(client, input3) {
-  return safe(() => client.pm.listFeatures(input3.projectId));
+  const { projectId, ...filters } = input3;
+  return safe(() => client.pm.listFeatures(projectId, filters));
 }
 async function createFeature(client, input3) {
   return safe(() => client.pm.createFeature(input3));
 }
+async function createFeaturesBatch(client, input3) {
+  return safe(() => client.pm.createFeaturesBatch(input3.features));
+}
+async function deleteFeature(client, input3) {
+  return safe(async () => {
+    await client.pm.deleteFeature(input3.id);
+    return { ok: true, id: input3.id };
+  });
+}
 async function updateFeature(client, input3) {
   const { id, ...patch } = input3;
   return safe(() => client.pm.updateFeature(id, patch));
@@ -4704,7 +4961,10 @@ var createFeatureInputSchema = z4.object({
   currentStage: z4.enum(STAGE_VALUES).optional(),
   targetStage: z4.enum(STAGE_VALUES).optional(),
   status: z4.string().optional(),
-  clientDependencies: z4.string().optional()
+  clientDependencies: z4.string().optional(),
+  createdAt: z4.string().datetime().optional(),
+  phaseId: z4.string().uuid().optional(),
+  phaseIds: z4.array(z4.string().uuid()).optional()
 });
 var updateFeatureInputSchema = z4.object({
   id: z4.string().uuid(),
@@ -4723,9 +4983,14 @@ function registerFeatureTools(server, getClient2) {
     "list_features",
     {
       title: "List features",
-      description: "Lists every feature on the project. Each entry has id, name, category, description, current_stage, target_stage, status, prd_path, client_dependencies, and Linear epic url if synced.",
+      description: "Lists features on the project. Each entry has id, name, category, description, current_stage, target_stage, status, prd_path, client_dependencies, and Linear epic url if synced. Optional filters narrow server-side: phaseId returns only features assigned to that phase; status / category / currentStage / targetStage filter on the matching column.",
       inputSchema: {
-        projectId: z4.number().int().positive()
+        projectId: z4.number().int().positive(),
+        phaseId: z4.string().uuid().optional().describe("Limit to features assigned to this phase (phase_features join)."),
+        status: z4.string().optional().describe("Filter by status \u2014 typically not_started / in_progress / done."),
+        category: z4.string().optional().describe("Filter by roadmap category, exact match."),
+        currentStage: z4.enum(STAGE_VALUES).optional().describe("Filter by current_stage."),
+        targetStage: z4.enum(STAGE_VALUES).optional().describe("Filter by target_stage.")
       }
     },
     withClientArgs(getClient2, listFeatures)
@@ -4734,7 +4999,7 @@ function registerFeatureTools(server, getClient2) {
     "create_feature",
     {
       title: "Create feature",
-      description: "Creates a new feature on the project. The PM should review the proposed fields before this is called \u2014 this is a write operation. After creation, use assign_feature_to_phase to attach it to one or more phases.",
+      description: "Creates a new feature on the project. The PM should review the proposed fields before this is called \u2014 this is a write operation. Optionally pre-assigns the new feature to one or more phases via phaseId / phaseIds (atomic \u2014 feature + memberships land together or neither does). For roadmap migrations from older sources, pass createdAt to preserve the historical creation timestamp.",
       inputSchema: {
         projectId: z4.number().int().positive(),
         name: z4.string().min(1),
@@ -4744,11 +5009,42 @@ function registerFeatureTools(server, getClient2) {
         currentStage: z4.enum(STAGE_VALUES).optional().describe(`Default idea. ${STAGE_DESC}`),
         targetStage: z4.enum(STAGE_VALUES).optional().describe(`Default mv. ${STAGE_DESC}`),
         status: z4.string().optional().describe("Default not_started. Common values: not_started, in_progress, done."),
-        clientDependencies: z4.string().optional().describe("Free-text. What blockers from the client side, if any.")
+        clientDependencies: z4.string().optional().describe("Free-text. What blockers from the client side, if any."),
+        createdAt: z4.string().datetime().optional().describe(
+          "ISO 8601 timestamp. Backdates the row's createdAt \u2014 only set this when migrating an existing roadmap that has a real historical creation date. Otherwise omit and the server stamps now()."
+        ),
+        phaseId: z4.string().uuid().optional().describe("Atomically assign the new feature to this phase. Same project required."),
+        phaseIds: z4.array(z4.string().uuid()).optional().describe(
+          "Atomically assign the new feature to multiple phases. Same project required for every phase."
+        )
       }
     },
     withClientArgs(getClient2, createFeature)
   );
+  server.registerTool(
+    "create_features_batch",
+    {
+      title: "Create features batch",
+      description: `Bulk feature create \u2014 accepts an array of inputs (max 200) and returns one result per input with success or error. Each item is wrapped in its own transaction (feature + phase memberships if any), so partial failures don't sink the whole batch. Built for one-shot migrations of an existing roadmap (Excel "Features List" sheets etc).`,
+      inputSchema: {
+        features: z4.array(createFeatureInputSchema).min(1).max(200).describe("Up to 200 feature inputs. Each accepts the same fields as create_feature.")
+      }
+    },
+    withClientArgs(getClient2, createFeaturesBatch)
+  );
+  server.registerTool(
+    "delete_feature",
+    {
+      title: "Delete feature (DESTRUCTIVE \u2014 hard delete, no undo)",
+      description: `\u26A0 DESTRUCTIVE. Hard-deletes the feature row from postgres. Not a soft archive \u2014 the row is gone, the DB cascades all phase_features memberships so the feature disappears from every phase it was attached to, and there is no recovery short of restoring the database from backup. Use ONLY for rolling back a bad insert during a migration or removing a feature created in error. 
+
+Mandatory caller behavior: present the feature's name + id + every phase it currently belongs to to the PM, get explicit confirmation ("yes, delete <name>"), then call. Never call without that confirmation. If you have any doubt, prefer marking the feature's status to something like "cancelled" via update_feature instead \u2014 that preserves history.`,
+      inputSchema: {
+        id: z4.string().uuid().describe("Feature id from list_features or create_feature.")
+      }
+    },
+    withClientArgs(getClient2, deleteFeature)
+  );
   server.registerTool(
     "update_feature",
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.154.2",
+  "version": "4.155.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",