OUT-4029 | Stop generating task labels; keep label for backward compatibility

Stops generating per-task label codes and deletes LabelMappingService and the
Labels registry table. Keeps the Tasks.label column (now @default('')) so the
public automation API stays backward compatible: pre-existing tasks keep their
codes, new tasks return ''.

- Public API: label retained in PublicTaskDtoSchema + serializer, with a
  serializer test locking the contract (empty for new, preserved for old).
- Internal app no longer uses label — drag preview shows the workflow-state
  icon, the breadcrumb shows the task title, the search filter drops the label
  matcher.
- Breadcrumb: desktop truncates the title at 25 chars; below 600px it uses a
  shorter 12-char title to avoid the platform header overflowing.
- Migration (edited in place): set Tasks.label DEFAULT '' and DROP TABLE Labels
  (the column is kept, not dropped).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: SandipBajracharya

prisma/migrations/20260825000000_drop_task_label_and_labels_table/migration.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "Tasks" ALTER COLUMN "label" SET DEFAULT '';
+DROP TABLE "Labels";

prisma/schema/label.prisma

@@ -11,7 +11,7 @@ enum Source {
 
 model Task {
   id              String        @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
-  label           String
+  label           String        @default("")
   workspaceId     String        @db.VarChar(32)
   assigneeId      String?       @db.Uuid
   internalUserId  String?       @db.Uuid

prisma/schema/task.prisma

@@ -0,0 +1,69 @@
+jest.mock('@/utils/CopilotAPI', () => ({ CopilotAPI: class {} }))
+jest.mock('@/lib/db', () => ({ __esModule: true, default: { getInstance: () => ({}) } }))
+jest.mock('@/app/api/attachments/public/public.serializer', () => ({
+  PublicAttachmentSerializer: { serializeAttachments: jest.fn(async () => []) },
+}))
+jest.mock('@/utils/santizeContents', () => ({ sanitizeHtml: (value: string) => value }))
+jest.mock('@/utils/signedUrlReplacer', () => ({
+  replaceMediaSources: jest.fn(async (value: string) => value),
+  replaceImageSrc: jest.fn(async (value: string) => value),
+}))
+jest.mock('@/utils/signUrl', () => ({ getSignedUrl: jest.fn(async (value: string) => value) }))
+jest.mock('@/utils/signedTemplateUrlReplacer', () => ({
+  copyTemplateMediaToTask: jest.fn(async (_workspaceId: string, value: string) => value),
+}))
+
+import { PublicTaskSerializer, TaskWithWorkflowStateAndAttachments } from './public.serializer'
+
+const IU_ID = '22222222-2222-2222-2222-222222222222'
+
+const makeTask = (overrides: Partial<TaskWithWorkflowStateAndAttachments> = {}): TaskWithWorkflowStateAndAttachments =>
+  ({
+    id: '11111111-1111-1111-1111-111111111111',
+    title: 'A task',
+    body: null,
+    parentId: null,
+    dueDate: null,
+    label: '',
+    templateId: null,
+    createdById: IU_ID,
+    completedAt: null,
+    createdAt: new Date('2026-01-01T00:00:00.000Z'),
+    isArchived: false,
+    lastArchivedDate: null,
+    archivedBy: null,
+    deletedAt: null,
+    source: 'api',
+    deletedBy: null,
+    completedBy: null,
+    completedByUserType: null,
+    internalUserId: IU_ID,
+    clientId: null,
+    companyId: null,
+    associations: [],
+    isShared: false,
+    workflowState: { type: 'started' },
+    attachments: [],
+    ...overrides,
+  }) as unknown as TaskWithWorkflowStateAndAttachments
+
+// OUT-4029: label generation was removed but the public API keeps the `label`
+// field for backward compatibility — empty string for new tasks, the stored
+// value for pre-existing ones. These lock that contract so a future change
+// can't silently drop the field again.
+describe('PublicTaskSerializer — label backward compatibility', () => {
+  it('returns an empty-string label for tasks created after label generation was removed', async () => {
+    const result = await PublicTaskSerializer.serializeUnsafe(makeTask({ label: '' }))
+    expect(result.label).toBe('')
+  })
+
+  it('preserves the pre-existing generated label for older tasks', async () => {
+    const result = await PublicTaskSerializer.serializeUnsafe(makeTask({ label: 'OUT-001' }))
+    expect(result.label).toBe('OUT-001')
+  })
+
+  it('keeps label in the schema-validated public DTO', async () => {
+    const result = await PublicTaskSerializer.serialize(makeTask({ label: 'OUT-001' }))
+    expect(result.label).toBe('OUT-001')
+  })
+})

src/app/api/label-mapping/label-mapping.service.ts

@@ -20,7 +20,6 @@ import { AssigneeType, Prisma, PrismaClient, Source, StateType, Task, TaskTempla
 import httpStatus from 'http-status'
 import z from 'zod'
 import APIError from '@api/core/exceptions/api'
-import { LabelMappingService } from '@api/label-mapping/label-mapping.service'
 import { SubtaskService } from '@api/tasks/subtasks.service'
 import { TasksActivityLogger } from '@api/tasks/tasks.logger'
 import { TemplatesService } from '@api/tasks/templates/templates.service'
@@ -143,10 +142,6 @@ export class PublicTasksService extends TasksSharedService {
       companyId: validatedIds.companyId,
     })
 
-    //generate the label
-    const labelMappingService = new LabelMappingService(this.user)
-    const label = z.string().parse(await labelMappingService.getLabel(validatedIds))
-    console.info('PublicTasksService#createTask | Generated label for task:', label)
     if (data.parentId) {
       const canCreateSubTask = await this.canCreateSubTask(data.parentId)
       if (!canCreateSubTask) {
@@ -190,7 +185,6 @@ export class PublicTasksService extends TasksSharedService {
         ...data,
         workspaceId: this.user.workspaceId,
         createdById,
-        label: label,
         completedBy,
         completedByUserType,
         source: Source.api,
@@ -364,16 +358,6 @@ export class PublicTasksService extends TasksSharedService {
     const subtaskService = new SubtaskService(this.user)
 
     let updatedTask = await this.db.$transaction(async (tx) => {
-      //generate new label if prevTask has no assignee but now assigned to someone
-      let label: string = prevTask.label
-      if (!prevTask.assigneeId && assigneeId && assigneeType) {
-        const labelMappingService = new LabelMappingService(this.user)
-        labelMappingService.setTransaction(tx as PrismaClient)
-        if (validatedIds) {
-          label = z.string().parse(await labelMappingService.getLabel(validatedIds))
-        }
-      }
-
       // Set / reset lastArchivedDate if isArchived has been triggered, else remove it from the update query
       let lastArchivedDate: Date | undefined | null = undefined
       let archivedBy: string | null | undefined = undefined
@@ -387,7 +371,6 @@ export class PublicTasksService extends TasksSharedService {
         where: { id },
         data: {
           ...dataWithoutUserIds,
-          label,
           lastArchivedDate,
           archivedBy,
           completedBy,

src/app/api/tasks/public/public.serializer.test.ts

@@ -21,21 +21,20 @@ describe('SubtaskService.softDeleteAllSubtasks (integration)', () => {
   beforeEach(truncateAll)
   afterAll(disconnectTestDb)
 
-  // Reproduces OUT-4029: colliding label strings across workspaces must not cause cross-workspace deletes.
-  it('deletes only the acting workspace subtree when a descendant shares a label string with another workspace', async () => {
+  // OUT-4029: deletion is scoped by id + workspaceId. A task in another workspace must
+  // never be soft-deleted when we delete the acting workspace's subtree.
+  it('deletes only the acting workspace subtree and leaves other workspaces untouched', async () => {
     const workspaceA = 'ws-a'
     const workspaceB = 'ws-b'
-    const sharedLabel = 'THE10-001'
 
-    // Root is soft-deleted before softDeleteAllSubtasks runs (as in the real call sites), so
-    // the query returns only live descendants — the collision is on childA.
-    const rootA = await seedTask({ workspaceId: workspaceA, label: 'THE10-000', deletedAt: new Date() })
-    const childA = await seedTask({ workspaceId: workspaceA, parentId: rootA, label: sharedLabel })
+    // Root is soft-deleted before softDeleteAllSubtasks runs (as at the real call sites),
+    // so the descendant query returns only the live child.
+    const rootA = await seedTask({ workspaceId: workspaceA, deletedAt: new Date() })
+    const childA = await seedTask({ workspaceId: workspaceA, parentId: rootA })
     await setPath(rootA, rootA)
     await setPath(childA, rootA, childA)
 
-    // Different workspace, different id, but the SAME label string as descendant childA.
-    const taskB = await seedTask({ workspaceId: workspaceB, label: sharedLabel })
+    const taskB = await seedTask({ workspaceId: workspaceB })
     await setPath(taskB, taskB)
 
     await new SubtaskService(makeUser(workspaceA)).softDeleteAllSubtasks(rootA)
@@ -47,7 +46,6 @@ describe('SubtaskService.softDeleteAllSubtasks (integration)', () => {
     ])
 
     expect(ca?.deletedAt).not.toBeNull()
-    // The colliding-label task in the other workspace must survive.
     expect(b?.deletedAt).toBeNull()
   })
 })

src/app/api/tasks/public/public.service.ts

@@ -1,14 +1,12 @@
 const mockQueryRawUnsafe = jest.fn()
 const mockTaskDeleteMany = jest.fn()
-const mockLabelDeleteMany = jest.fn()
 
 jest.mock('@/lib/db', () => ({
   __esModule: true,
   default: {
     getInstance: () => ({
       $queryRawUnsafe: mockQueryRawUnsafe,
       task: { deleteMany: mockTaskDeleteMany },
-      label: { deleteMany: mockLabelDeleteMany },
     }),
   },
 }))
@@ -38,12 +36,4 @@ describe('SubtaskService#softDeleteAllSubtasks', () => {
       where: { id: { in: ['task-a', 'task-b'] }, workspaceId: 'ws-1' },
     })
   })
-
-  it('never deletes Labels registry rows', async () => {
-    mockQueryRawUnsafe.mockResolvedValue([{ id: 'task-a' }])
-
-    await new SubtaskService(user).softDeleteAllSubtasks('parent-id')
-
-    expect(mockLabelDeleteMany).not.toHaveBeenCalled()
-  })
 })

src/app/api/tasks/subtasks.service.integration.test.ts

@@ -88,7 +88,7 @@ export class SubtaskService extends BaseService {
       )
     ).map((row) => row.id)
 
-    // Scope by id + workspaceId: label strings collide across workspaces (Labels has no workspaceId).
+    // Scope by id + workspaceId so a delete never crosses into another workspace's tasks.
     await this.db.task.deleteMany({ where: { id: { in: subtaskIds }, workspaceId: this.user.workspaceId } })
   }