crewx 0.9.0-rc.73 → 0.9.0-rc.74

package/dist-server/common/validation.pipe.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapThreadLabelValidationError = mapThreadLabelValidationError;
+exports.createServerValidationPipe = createServerValidationPipe;
+const common_1 = require("@nestjs/common");
+const THREAD_LABEL_DTO_NAMES = new Set([
+    'ThreadLabelListQueryDto',
+    'CreateThreadLabelDto',
+    'UpdateThreadLabelDto',
+    'ArchiveThreadLabelDto',
+]);
+const SERVER_VALIDATION_PIPE_OPTIONS = {
+    whitelist: true,
+    transform: true,
+};
+// Delegate non-thread-label errors to Nest's own factory so nested paths and envelopes stay unchanged.
+const defaultExceptionFactory = new common_1.ValidationPipe(SERVER_VALIDATION_PIPE_OPTIONS).createExceptionFactory();
+function isThreadLabelValidationError(error) {
+    const target = error.target;
+    if (!target || typeof target !== 'object')
+        return false;
+    const constructorName = target.constructor?.name;
+    return typeof constructorName === 'string' && THREAD_LABEL_DTO_NAMES.has(constructorName);
+}
+function hasConstraint(errors, properties, constraint) {
+    return errors.some((error) => isThreadLabelValidationError(error)
+        && properties.includes(error.property)
+        && Boolean(error.constraints?.[constraint]));
+}
+/** Translate only thread-label DTO type errors; other DTOs keep Nest's normal messages. */
+function mapThreadLabelValidationError(errors) {
+    if (hasConstraint(errors, ['kind'], 'isString'))
+        return 'THREAD_LABEL_KIND_INVALID';
+    if (hasConstraint(errors, ['name', 'nameOverride'], 'isString'))
+        return 'THREAD_LABEL_INVALID_NAME';
+    if (hasConstraint(errors, ['color'], 'isString'))
+        return 'THREAD_LABEL_INVALID_COLOR';
+    return undefined;
+}
+/** The application-wide pipe, including stable thread-label validation codes. */
+function createServerValidationPipe() {
+    return new common_1.ValidationPipe({
+        ...SERVER_VALIDATION_PIPE_OPTIONS,
+        exceptionFactory: (errors) => {
+            const machineCode = mapThreadLabelValidationError(errors);
+            return machineCode
+                ? new common_1.BadRequestException(machineCode)
+                : defaultExceptionFactory(errors);
+        },
+    });
+}

package/dist-server/domain/thread/dto/thread-label.dto.js

@@ -0,0 +1,93 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiveThreadLabelDto = exports.UpdateThreadLabelDto = exports.CreateThreadLabelDto = exports.ThreadLabelListQueryDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const repository_1 = require("@crewx/sdk/repository");
+class ThreadLabelListQueryDto {
+    kind;
+    includeArchived;
+}
+exports.ThreadLabelListQueryDto = ThreadLabelListQueryDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: ['state', 'priority'] }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ThreadLabelListQueryDto.prototype, "kind", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ default: false }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if (typeof value === 'boolean')
+            return value;
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        return value;
+    }),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], ThreadLabelListQueryDto.prototype, "includeArchived", void 0);
+class CreateThreadLabelDto {
+    name;
+    color;
+}
+exports.CreateThreadLabelDto = CreateThreadLabelDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateThreadLabelDto.prototype, "name", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: repository_1.COMMON_CODE_COLORS }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateThreadLabelDto.prototype, "color", void 0);
+class UpdateThreadLabelDto {
+    nameOverride;
+    color;
+}
+exports.UpdateThreadLabelDto = UpdateThreadLabelDto;
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ nullable: true }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", Object)
+], UpdateThreadLabelDto.prototype, "nameOverride", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ enum: repository_1.COMMON_CODE_COLORS }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], UpdateThreadLabelDto.prototype, "color", void 0);
+class ArchiveThreadLabelDto {
+    archived;
+}
+exports.ArchiveThreadLabelDto = ArchiveThreadLabelDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if (typeof value === 'boolean')
+            return value;
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        return value;
+    }),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], ArchiveThreadLabelDto.prototype, "archived", void 0);

package/dist-server/domain/thread/dto/update-thread.dto.js

@@ -21,10 +21,10 @@ function IsThreadStateValue() {
             propertyName,
             validator: {
                 validate(value) {
-                    return (0, thread_title_types_js_1.isThreadState)(value);
+                    return (0, thread_title_types_js_1.isThreadState)(value) && !(typeof value === 'string' && value.startsWith('custom:'));
                 },
                 defaultMessage() {
-                    return 'state must be a built-in thread state or custom:<label> (1-20 chars)';
+                    return 'state must be a stable thread-state code';
                 },
             },
         });
@@ -37,7 +37,7 @@ class UpdateThreadDto {
 }
 exports.UpdateThreadDto = UpdateThreadDto;
 __decorate([
-    (0, swagger_1.ApiPropertyOptional)({ description: 'Thread name only (1–120 chars). Server does not parse chips.' }),
+    (0, swagger_1.ApiPropertyOptional)({ description: 'Thread name (1–120 chars). Legacy composite titles are parsed only when exact aliases match.' }),
     (0, class_validator_1.ValidateIf)((_obj, value) => value !== undefined),
     (0, class_validator_1.IsString)(),
     (0, class_validator_1.MinLength)(1),
@@ -57,7 +57,7 @@ __decorate([
 ], UpdateThreadDto.prototype, "priority", void 0);
 __decorate([
     (0, swagger_1.ApiPropertyOptional)({
-        description: 'Thread progress value. null clears the stored state. custom:<label> is allowed.',
+        description: 'Thread progress code. null clears the stored state.',
         nullable: true,
     }),
     (0, class_validator_1.ValidateIf)((_obj, value) => value !== undefined && value !== null),

package/dist-server/domain/thread/thread-label.controller.js

@@ -0,0 +1,90 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadLabelController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const workspace_decorator_js_1 = require("../../common/decorators/workspace.decorator.js");
+const thread_label_dto_js_1 = require("./dto/thread-label.dto.js");
+const thread_label_service_js_1 = require("./thread-label.service.js");
+let ThreadLabelController = class ThreadLabelController {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    list(query, ws) {
+        return this.service.list(query.kind, ws.id, query.includeArchived ?? false);
+    }
+    create(kind, dto, ws) {
+        return { item: this.service.create(kind, ws.id, dto) };
+    }
+    update(kind, code, dto, ws) {
+        return { item: this.service.update(kind, code, ws.id, dto) };
+    }
+    archive(kind, code, dto, ws) {
+        return { item: this.service.archive(kind, code, ws.id, dto.archived) };
+    }
+};
+exports.ThreadLabelController = ThreadLabelController;
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'THD.LABEL.LIST', summary: 'List conversation state or priority labels' }),
+    (0, swagger_1.ApiQuery)({ name: 'kind', required: true, enum: ['state', 'priority'] }),
+    (0, swagger_1.ApiQuery)({ name: 'includeArchived', required: false, type: Boolean }),
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Query)()),
+    __param(1, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [thread_label_dto_js_1.ThreadLabelListQueryDto, Object]),
+    __metadata("design:returntype", void 0)
+], ThreadLabelController.prototype, "list", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'THD.LABEL.CREATE', summary: 'Create a conversation state label' }),
+    (0, common_1.Post)(':kind'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.CREATED),
+    __param(0, (0, common_1.Param)('kind')),
+    __param(1, (0, common_1.Body)()),
+    __param(2, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, thread_label_dto_js_1.CreateThreadLabelDto, Object]),
+    __metadata("design:returntype", void 0)
+], ThreadLabelController.prototype, "create", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'THD.LABEL.UPDATE', summary: 'Update a conversation label display' }),
+    (0, common_1.Patch)(':kind/:code'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    __param(0, (0, common_1.Param)('kind')),
+    __param(1, (0, common_1.Param)('code')),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, thread_label_dto_js_1.UpdateThreadLabelDto, Object]),
+    __metadata("design:returntype", void 0)
+], ThreadLabelController.prototype, "update", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'THD.LABEL.ARCHIVE', summary: 'Archive or restore a conversation label' }),
+    (0, common_1.Post)(':kind/:code/archive'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    __param(0, (0, common_1.Param)('kind')),
+    __param(1, (0, common_1.Param)('code')),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, thread_label_dto_js_1.ArchiveThreadLabelDto, Object]),
+    __metadata("design:returntype", void 0)
+], ThreadLabelController.prototype, "archive", null);
+exports.ThreadLabelController = ThreadLabelController = __decorate([
+    (0, swagger_1.ApiTags)('thread-labels'),
+    (0, common_1.Controller)('ws/:slug/thread-labels'),
+    __metadata("design:paramtypes", [thread_label_service_js_1.ThreadLabelService])
+], ThreadLabelController);

package/dist-server/domain/thread/thread-label.service.js

@@ -0,0 +1,238 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadLabelService = void 0;
+exports.parseThreadLabelKind = parseThreadLabelKind;
+const common_1 = require("@nestjs/common");
+const repository_1 = require("@crewx/sdk/repository");
+const thread_label_repository_js_1 = require("../../repository/thread-label.repository.js");
+const PRIORITY_DEFAULT_ALIASES = {
+    urgent: 'U 긴급 Urgent',
+    high: 'P0 급함 High',
+    medium: 'P1 중요 Medium',
+    low: 'P2 보통 Low',
+};
+const STATE_DEFAULT_ALIASES = {
+    investigating: '조사중 Looking into',
+    'in-progress': '진행중 In progress',
+    'in-review': '검토중 In review',
+    'on-hold': '보류 On hold',
+    done: '완료 Done',
+};
+const DEFAULT_NAME_KEYS = {
+    urgent: 'threadTitle.priority.urgent',
+    high: 'threadTitle.priority.high',
+    medium: 'threadTitle.priority.medium',
+    low: 'threadTitle.priority.low',
+    investigating: 'threadTitle.state.investigating',
+    'in-progress': 'threadTitle.state.in-progress',
+    'in-review': 'threadTitle.state.in-review',
+    'on-hold': 'threadTitle.state.on-hold',
+    done: 'threadTitle.state.done',
+};
+function appendSearchAlias(existing, name) {
+    const normalized = name.trim();
+    if (!existing)
+        return normalized;
+    if (!normalized || existing.includes(normalized))
+        return existing;
+    return `${existing} ${normalized}`;
+}
+function parseThreadLabelKind(value) {
+    if (value === 'state' || value === 'priority')
+        return value;
+    throw new common_1.BadRequestException('THREAD_LABEL_KIND_INVALID');
+}
+function isThreadLabelColor(value) {
+    return typeof value === 'string' && repository_1.COMMON_CODE_COLORS.includes(value);
+}
+function normalizeName(value) {
+    const name = typeof value === 'string' ? value.trim() : '';
+    const length = [...name].length;
+    if (length < 1 || length > 20) {
+        throw new common_1.BadRequestException('THREAD_LABEL_INVALID_NAME');
+    }
+    return name;
+}
+function normalizeColor(value) {
+    if (!isThreadLabelColor(value)) {
+        throw new common_1.BadRequestException('THREAD_LABEL_INVALID_COLOR');
+    }
+    return value;
+}
+function mapDefaultNameKey(row) {
+    return row.is_builtin === 1 ? DEFAULT_NAME_KEYS[row.code] ?? null : null;
+}
+function mapItem(kind, row) {
+    const color = isThreadLabelColor(row.color) ? row.color : 'gray';
+    return {
+        group: kind,
+        code: row.code,
+        nameOverride: row.code_name,
+        nameSource: row.code_name === null ? 'default' : 'user',
+        defaultNameKey: mapDefaultNameKey(row),
+        color,
+        sortOrder: row.sort_order,
+        scope: row.workspace_id === null ? 'global' : 'workspace',
+        isBuiltin: row.is_builtin === 1,
+        isArchived: row.is_archived === 1,
+    };
+}
+function mapRepositoryError(error) {
+    if (!(error instanceof repository_1.CommonCodeRepositoryError))
+        throw error;
+    switch (error.reason) {
+        case 'COMMON_CODE_NAME_INVALID':
+        case 'COMMON_CODE_UPDATE_EMPTY':
+            throw new common_1.BadRequestException('THREAD_LABEL_INVALID_NAME');
+        case 'COMMON_CODE_COLOR_INVALID':
+            throw new common_1.BadRequestException('THREAD_LABEL_INVALID_COLOR');
+        case 'COMMON_CODE_BUILTIN_ARCHIVE_FORBIDDEN':
+            throw new common_1.BadRequestException('THREAD_LABEL_BUILTIN_ARCHIVE_FORBIDDEN');
+        case 'COMMON_CODE_NAME_CONFLICT':
+            throw new common_1.ConflictException('THREAD_LABEL_NAME_CONFLICT');
+        case 'COMMON_CODE_NOT_FOUND':
+        case 'COMMON_CODE_SCOPE_FORBIDDEN':
+            throw new common_1.NotFoundException('THREAD_LABEL_NOT_FOUND');
+        default:
+            throw error;
+    }
+}
+/** Feature-level service that translates SDK ledger rows to the thread-label wire contract. */
+let ThreadLabelService = class ThreadLabelService {
+    labels;
+    constructor(labels = new thread_label_repository_js_1.ThreadLabelRepository()) {
+        this.labels = labels;
+    }
+    list(kindValue, workspaceId, includeArchived = false) {
+        const kind = parseThreadLabelKind(kindValue);
+        try {
+            return { items: this.labels.list(kind, workspaceId, includeArchived).map((row) => mapItem(kind, row)) };
+        }
+        catch (error) {
+            return mapRepositoryError(error);
+        }
+    }
+    create(kindValue, workspaceId, input) {
+        const kind = parseThreadLabelKind(kindValue);
+        if (kind === 'priority')
+            throw new common_1.BadRequestException('THREAD_LABEL_KIND_READ_ONLY');
+        const name = normalizeName(input.name);
+        const color = normalizeColor(input.color);
+        try {
+            return mapItem(kind, this.labels.createState(workspaceId, name, color));
+        }
+        catch (error) {
+            return mapRepositoryError(error);
+        }
+    }
+    update(kindValue, code, workspaceId, input) {
+        const kind = parseThreadLabelKind(kindValue);
+        const update = {};
+        if (input.nameOverride !== undefined) {
+            if (input.nameOverride === null)
+                update.name = null;
+            else
+                update.name = normalizeName(input.nameOverride);
+        }
+        if (input.color !== undefined)
+            update.color = normalizeColor(input.color);
+        try {
+            return mapItem(kind, this.labels.update(kind, code, workspaceId, update));
+        }
+        catch (error) {
+            return mapRepositoryError(error);
+        }
+    }
+    archive(kindValue, code, workspaceId, archivedValue) {
+        const kind = parseThreadLabelKind(kindValue);
+        if (typeof archivedValue !== 'boolean')
+            throw new common_1.BadRequestException('THREAD_LABEL_INVALID_NAME');
+        try {
+            return mapItem(kind, this.labels.archive(kind, code, workspaceId, archivedValue));
+        }
+        catch (error) {
+            return mapRepositoryError(error);
+        }
+    }
+    /** Validate a new metadata reference; archived codes are read-only history. */
+    assertSelectable(kindValue, code, workspaceId) {
+        const kind = parseThreadLabelKind(kindValue);
+        const row = this.labels.resolve(kind, code, workspaceId);
+        if (!row)
+            throw new common_1.NotFoundException('THREAD_LABEL_NOT_FOUND');
+        if (row.is_archived === 1)
+            throw new common_1.ConflictException('THREAD_LABEL_ARCHIVED');
+        return row;
+    }
+    resolve(kindValue, code, workspaceId) {
+        const kind = parseThreadLabelKind(kindValue);
+        return this.labels.resolve(kind, code, workspaceId);
+    }
+    /** Map exact legacy state suffix names to stable codes for compatibility parsing. */
+    stateAliases(workspaceId) {
+        const aliases = new Map();
+        for (const [code, names] of Object.entries(STATE_DEFAULT_ALIASES)) {
+            aliases.set(names.split(' ')[0], code);
+            aliases.set(names.split(' ').slice(1).join(' '), code);
+        }
+        try {
+            for (const row of this.labels.list('state', workspaceId, true)) {
+                if (row.code_name !== null)
+                    aliases.set(row.code_name, row.code);
+            }
+        }
+        catch {
+            // Search/backfill remains available for builtin aliases if the ledger is unavailable.
+        }
+        return aliases;
+    }
+    /** Include stable codes, built-in KO/EN aliases, and current display names in q search. */
+    searchAliases(workspaceId) {
+        const aliases = new Map();
+        for (const [code, names] of Object.entries(PRIORITY_DEFAULT_ALIASES)) {
+            aliases.set(code, names);
+        }
+        for (const [code, names] of Object.entries(STATE_DEFAULT_ALIASES)) {
+            aliases.set(code, names);
+        }
+        try {
+            for (const kind of ['state', 'priority']) {
+                for (const row of this.labels.list(kind, workspaceId, true)) {
+                    if (row.code_name !== null) {
+                        aliases.set(row.code, appendSearchAlias(aliases.get(row.code), row.code_name));
+                    }
+                }
+            }
+        }
+        catch {
+            // A missing optional ledger must not hide the raw thread code from reads.
+        }
+        return aliases;
+    }
+    /** Return a code for a strict legacy state name, including archived history. */
+    findStateCodeByName(name, workspaceId) {
+        const builtin = this.stateAliases(workspaceId).get(name);
+        if (builtin)
+            return builtin;
+        try {
+            return this.labels.findByName('state', name, workspaceId)?.code ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+exports.ThreadLabelService = ThreadLabelService;
+exports.ThreadLabelService = ThreadLabelService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [thread_label_repository_js_1.ThreadLabelRepository])
+], ThreadLabelService);

package/dist-server/domain/thread/thread-title-common-code.backfill.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runThreadTitleCommonCodeBackfill = runThreadTitleCommonCodeBackfill;
+const sdk_1 = require("@crewx/sdk");
+const thread_title_types_js_1 = require("./thread-title.types.js");
+const thread_title_backfill_js_1 = require("./thread-title.backfill.js");
+/**
+ * Run the SDK data migration and then clean only strictly recognized composite
+ * titles. The settings value is read as migration input and never updated.
+ */
+function runThreadTitleCommonCodeBackfill(deps) {
+    const configuredLabels = (0, thread_title_backfill_js_1.readProgressExtras)(deps.globalSettingsStore);
+    const migration = (0, sdk_1.migrateLegacyThreadTitleCommonCodes)({ configuredLabels });
+    let compositeTitlesCleaned = 0;
+    const aliasesByWorkspace = new Map();
+    for (const row of deps.threadRepo.findAllThreads()) {
+        const workspaceKey = row.workspace_id ?? '';
+        let aliases = aliasesByWorkspace.get(workspaceKey);
+        if (!aliases) {
+            aliases = deps.threadLabelService.stateAliases(row.workspace_id ?? undefined);
+            aliasesByWorkspace.set(workspaceKey, aliases);
+        }
+        const parsed = (0, thread_title_backfill_js_1.parseCompositeThreadTitle)(row.title ?? '', aliases);
+        if (!parsed)
+            continue;
+        // Existing threadTitle metadata is authoritative. Only remove the stale
+        // string decoration from the title; do not infer or overwrite metadata.
+        if ((0, thread_title_types_js_1.hasThreadTitleKey)(row.metadata)) {
+            if (parsed.name !== (row.title ?? '')) {
+                deps.threadRepo.updateThreadTitle(row.id, parsed.name, row.workspace_id ?? undefined);
+                compositeTitlesCleaned += 1;
+            }
+            continue;
+        }
+        const written = deps.threadRepo.updateThreadTitleMeta(row.id, {
+            ...(parsed.priority !== undefined ? { priority: parsed.priority } : {}),
+            ...(parsed.state !== undefined ? { state: parsed.state } : {}),
+        }, row.workspace_id ?? undefined, { title: parsed.name });
+        if (written)
+            compositeTitlesCleaned += 1;
+    }
+    deps.logger?.log(`[thread-title] common-code migration: migratedRows=${migration.migratedRows}, ` +
+        `createdCodes=${migration.createdCodes}, remainingCustomReferences=${migration.remainingCustomReferences}, ` +
+        `orphanReferences=${migration.orphanReferences}, compositeTitlesCleaned=${compositeTitlesCleaned}`);
+    if (migration.remainingCustomReferences > 0 || migration.orphanReferences > 0) {
+        deps.logger?.warn(`[thread-title] common-code migration diagnostics: remaining custom/orphan references require attention ` +
+            `(custom=${migration.remainingCustomReferences}, orphan=${migration.orphanReferences})`);
+    }
+    return { ...migration, compositeTitlesCleaned };
+}

package/dist-server/domain/thread/thread-title.backfill.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LEGACY_PROGRESS_LABELS = void 0;
 exports.readProgressExtras = readProgressExtras;
 exports.parseLegacyThreadTitle = parseLegacyThreadTitle;
+exports.parseCompositeThreadTitle = parseCompositeThreadTitle;
 exports.runThreadTitleBackfill = runThreadTitleBackfill;
 const sdk_1 = require("@crewx/sdk");
 const thread_title_types_js_1 = require("./thread-title.types.js");
@@ -20,6 +21,7 @@ const PREFIX_MAP = {
     P2: 'low',
 };
 const PREFIX_RE = /^(U|P0|P1|P2) /;
+const COMPOSITE_PREFIX_RE = /^(U|P0|P1|P2)(?= |$)/;
 const TITLE_SEP = ' - ';
 const BUILTIN_STATE_LABELS = {
     조사중: 'investigating',
@@ -110,6 +112,37 @@ function parseLegacyThreadTitle(title, extraLabels) {
         return null;
     return { name, priority, state, matchedLegacyLabel };
 }
+/**
+ * Parse a legacy composite title against the already migrated state ledger.
+ * Unknown suffixes and empty post-split names return null so callers preserve
+ * the exact original title. This parser is compatibility-only; new requests
+ * send title, priority, and state separately.
+ */
+function parseCompositeThreadTitle(title, stateAliases) {
+    let rest = title;
+    let priority;
+    const prefix = rest.match(COMPOSITE_PREFIX_RE);
+    if (prefix) {
+        priority = PREFIX_MAP[prefix[1]];
+        rest = rest.slice(prefix[0].length);
+    }
+    let state;
+    const sepIdx = rest.lastIndexOf(TITLE_SEP);
+    if (sepIdx >= 0) {
+        const suffix = rest.slice(sepIdx + TITLE_SEP.length);
+        const parsedState = stateAliases.get(suffix);
+        if (!parsedState)
+            return null;
+        state = parsedState;
+        rest = rest.slice(0, sepIdx);
+    }
+    if (!priority && !state)
+        return null;
+    const name = rest.trim();
+    if (name.length === 0)
+        return null;
+    return { name, priority, state };
+}
 function appendProgressExtras(store, labels) {
     if (labels.length === 0)
         return [];

package/dist-server/domain/thread/thread-title.types.js

@@ -37,6 +37,11 @@ const STATE_SEARCH_TEXT = {
     'on-hold': '보류 On hold',
     done: '완료 Done',
 };
+function searchTextWithDefault(defaultText, currentText) {
+    if (!currentText || currentText.includes(defaultText))
+        return currentText ?? defaultText;
+    return `${defaultText} ${currentText}`;
+}
 function isThreadPriority(value) {
     return typeof value === 'string' && PRIORITY_SET.has(value);
 }
@@ -45,6 +50,8 @@ function isThreadState(value) {
         return false;
     if (BUILTIN_STATE_SET.has(value))
         return true;
+    if (value.startsWith('c_'))
+        return value.length > 2;
     if (!value.startsWith(CUSTOM_STATE_PREFIX))
         return false;
     const label = value.slice(CUSTOM_STATE_PREFIX.length);
@@ -119,16 +126,27 @@ function mergeThreadTitleMeta(metadataJson, patch) {
     return Object.keys(root).length === 0 ? null : JSON.stringify(root);
 }
 /** Search haystack so `q=P1` / `q=진행중` still match after title is name-only. */
-function threadTitleSearchHaystack(meta) {
+function threadTitleSearchHaystack(meta, labelNames = new Map()) {
     const parts = [];
-    if (meta.priority)
-        parts.push(PRIORITY_SEARCH_TEXT[meta.priority]);
+    if (meta.priority) {
+        parts.push(searchTextWithDefault(PRIORITY_SEARCH_TEXT[meta.priority], labelNames.get(meta.priority)));
+    }
     if (meta.state) {
         if (meta.state.startsWith(CUSTOM_STATE_PREFIX)) {
             parts.push(customStateLabel(meta.state) ?? '');
         }
+        else if (STATE_SEARCH_TEXT[meta.state]) {
+            parts.push(searchTextWithDefault(STATE_SEARCH_TEXT[meta.state], labelNames.get(meta.state)));
+        }
+        else if (labelNames.has(meta.state)) {
+            parts.push(meta.state, labelNames.get(meta.state) ?? '');
+        }
+        else if (meta.state.startsWith('c_')) {
+            // Keep an orphan stable code visible for fail-soft diagnostics.
+            parts.push(meta.state);
+        }
         else {
-            parts.push(STATE_SEARCH_TEXT[meta.state]);
+            parts.push(STATE_SEARCH_TEXT[meta.state] ?? '');
         }
     }
     return parts.filter(Boolean).join(' ');

package/dist-server/domain/thread/thread.module.js

@@ -9,7 +9,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadModule = void 0;
 const common_1 = require("@nestjs/common");
 const thread_controller_js_1 = require("./thread.controller.js");
+const thread_label_controller_js_1 = require("./thread-label.controller.js");
 const thread_service_js_1 = require("./thread.service.js");
+const thread_label_service_js_1 = require("./thread-label.service.js");
 const box_service_js_1 = require("../box/box.service.js");
 const crewx_module_js_1 = require("../../modules/crewx.module.js");
 let ThreadModule = class ThreadModule {
@@ -18,8 +20,8 @@ exports.ThreadModule = ThreadModule;
 exports.ThreadModule = ThreadModule = __decorate([
     (0, common_1.Module)({
         imports: [crewx_module_js_1.CrewxModule],
-        controllers: [thread_controller_js_1.ThreadController],
-        providers: [thread_service_js_1.ThreadService, box_service_js_1.BoxService],
+        controllers: [thread_controller_js_1.ThreadController, thread_label_controller_js_1.ThreadLabelController],
+        providers: [thread_service_js_1.ThreadService, thread_label_service_js_1.ThreadLabelService, box_service_js_1.BoxService],
         exports: [thread_service_js_1.ThreadService],
     })
 ], ThreadModule);

package/dist-server/domain/thread/thread.service.js

@@ -27,40 +27,63 @@ const provider_resume_js_1 = require("../../common/task-log/provider-resume.js")
 const pending_instruction_js_1 = require("../../common/pending-instruction.js");
 const task_error_projection_js_1 = require("../../common/task-error-projection.js");
 const overdrive_types_js_1 = require("./overdrive.types.js");
+const thread_title_common_code_backfill_js_1 = require("./thread-title-common-code.backfill.js");
+const thread_label_service_js_1 = require("./thread-label.service.js");
 const thread_title_backfill_js_1 = require("./thread-title.backfill.js");
 const thread_title_types_js_1 = require("./thread-title.types.js");
 // Legacy running-instruction text entries were persisted with a localized display
 // prefix before the structured `running_instruction` type existed. Match every known
 // locale prefix so classification stays language-neutral for a global product.
 const RUNNING_INSTRUCTION_LEGACY_PREFIXES = ['Running instruction:', '추가 지시:'];
-let ThreadService = ThreadService_1 = class ThreadService {
+let ThreadService = class ThreadService {
+    static { ThreadService_1 = this; }
     threadRepo;
     crewxPool;
     taskRepo;
     globalSettingsStore;
+    threadLabelService;
     logger = new common_1.Logger(ThreadService_1.name);
-    constructor(threadRepo, crewxPool, taskRepo = new task_repository_js_1.TaskRepository(), globalSettingsStore = (0, sdk_1.createGlobalSettingsStore)()) {
+    static commonCodeBackfillPaths = new Set();
+    constructor(threadRepo, crewxPool, taskRepo = new task_repository_js_1.TaskRepository(), globalSettingsStore = (0, sdk_1.createGlobalSettingsStore)(), threadLabelService = new thread_label_service_js_1.ThreadLabelService()) {
         this.threadRepo = threadRepo;
         this.crewxPool = crewxPool;
         this.taskRepo = taskRepo;
         this.globalSettingsStore = globalSettingsStore;
+        this.threadLabelService = threadLabelService;
     }
     onModuleInit() {
+        const dbPath = process.env.CREWX_DB || process.env.CREWX_TRACES_DB || 'default-crewx-db';
+        if (ThreadService_1.commonCodeBackfillPaths.has(dbPath))
+            return;
         try {
-            (0, thread_title_backfill_js_1.runThreadTitleBackfill)({
+            (0, thread_title_common_code_backfill_js_1.runThreadTitleCommonCodeBackfill)({
                 threadRepo: this.threadRepo,
+                threadLabelService: this.threadLabelService,
                 globalSettingsStore: this.globalSettingsStore,
                 logger: this.logger,
             });
+            ThreadService_1.commonCodeBackfillPaths.add(dbPath);
         }
         catch (e) {
             const err = e;
-            this.logger.error(`[thread-title] backfill failed: ${err.message}`);
+            this.logger.error(`[thread-title] common-code migration failed: ${err.message}`, err.stack);
         }
     }
     // THD.LIST: List threads from threads table (with optional q search)
     listThreads(params, workspaceId) {
-        const rows = this.threadRepo.findAllThreads(workspaceId);
+        const priorityFilter = (0, thread_title_types_js_1.parseThreadPriorityFilter)(params.priority);
+        const stateFilter = (0, thread_title_types_js_1.parseThreadStateFilter)(params.state);
+        const titleFilters = {
+            ...(priorityFilter ? {
+                priority: { values: [...priorityFilter.values], includeNone: priorityFilter.includeNone },
+            } : {}),
+            ...(stateFilter ? {
+                state: { values: [...stateFilter.values], includeNone: stateFilter.includeNone },
+            } : {}),
+        };
+        const rows = priorityFilter || stateFilter
+            ? this.threadRepo.findAllThreadsByTitleFilters(workspaceId, titleFilters)
+            : this.threadRepo.findAllThreads(workspaceId);
         // Filter by platform
         let filtered = rows;
         const platform = params.platform || 'all';
@@ -68,22 +91,14 @@ let ThreadService = ThreadService_1 = class ThreadService {
             filtered = filtered.filter((r) => r.platform === platform);
         }
         // Filter by stored priority/state values (between platform and q)
-        const priorityFilter = (0, thread_title_types_js_1.parseThreadPriorityFilter)(params.priority);
-        const stateFilter = (0, thread_title_types_js_1.parseThreadStateFilter)(params.state);
-        if (priorityFilter || stateFilter) {
-            filtered = filtered.filter((r) => {
-                const meta = (0, thread_title_types_js_1.readThreadTitleMeta)(r.metadata);
-                return ((0, thread_title_types_js_1.matchesThreadTitleFilter)(meta.priority, priorityFilter) &&
-                    (0, thread_title_types_js_1.matchesThreadTitleFilter)(meta.state, stateFilter));
-            });
-        }
+        const labelNames = this.threadLabelService.searchAliases(workspaceId);
         // Filter by search keyword (q param). Haystack includes tab codes + KO/EN labels
         // so habits like q=P1 / q=진행중 still match after title is name-only.
         if (params.q && params.q.trim().length > 0) {
             const queryLower = params.q.toLowerCase();
             filtered = filtered.filter((r) => {
                 const meta = (0, thread_title_types_js_1.readThreadTitleMeta)(r.metadata);
-                const text = [r.title, r.first_message, r.last_message, (0, thread_title_types_js_1.threadTitleSearchHaystack)(meta)]
+                const text = [r.title, r.first_message, r.last_message, (0, thread_title_types_js_1.threadTitleSearchHaystack)(meta, labelNames)]
                     .filter(Boolean)
                     .join(' ')
                     .toLowerCase();
@@ -216,19 +231,43 @@ let ThreadService = ThreadService_1 = class ThreadService {
             }
             title = trimmed;
         }
-        if (hasPriority || hasState) {
-            const written = this.threadRepo.updateThreadTitleMeta(threadId, {
-                ...(hasPriority ? { priority: patch.priority } : {}),
-                ...(hasState ? { state: patch.state } : {}),
-            }, workspaceId, hasTitle ? { title: title } : undefined);
+        const parsedTitle = hasTitle
+            ? (0, thread_title_backfill_js_1.parseCompositeThreadTitle)(title, this.threadLabelService.stateAliases(workspaceId))
+            : null;
+        if (parsedTitle)
+            title = parsedTitle.name;
+        const effectivePriority = hasPriority
+            ? patch.priority
+            : parsedTitle?.priority;
+        const effectiveState = hasState
+            ? patch.state
+            : parsedTitle?.state;
+        const hasEffectivePriority = hasPriority || parsedTitle?.priority !== undefined;
+        const hasEffectiveState = hasState || parsedTitle?.state !== undefined;
+        // Validate the thread before touching the ledger so cross-workspace thread
+        // updates never reveal or mutate another workspace's label set.
+        const existing = this.threadRepo.findThreadById(threadId, workspaceId);
+        if (!existing)
+            throw new common_1.NotFoundException('Thread not found');
+        if (hasEffectivePriority && effectivePriority !== null && effectivePriority !== undefined) {
+            this.threadLabelService.assertSelectable('priority', effectivePriority, workspaceId);
+        }
+        if (hasEffectiveState && effectiveState !== null && effectiveState !== undefined) {
+            this.threadLabelService.assertSelectable('state', effectiveState, workspaceId);
+        }
+        if (hasEffectivePriority || hasEffectiveState) {
+            const written = this.threadRepo.patchThreadTitleMetadata(threadId, {
+                ...(hasEffectivePriority ? { priority: effectivePriority } : {}),
+                ...(hasEffectiveState ? { state: effectiveState } : {}),
+            }, workspaceId);
             if (!written) {
-                throw new common_1.NotFoundException(`Thread not found: ${threadId}`);
+                throw new common_1.NotFoundException('Thread not found');
             }
         }
-        else {
+        if (hasTitle) {
             const updated = this.threadRepo.updateThreadTitle(threadId, title, workspaceId);
             if (!updated) {
-                throw new common_1.NotFoundException(`Thread not found: ${threadId}`);
+                throw new common_1.NotFoundException('Thread not found');
             }
         }
         const row = this.threadRepo.findThreadById(threadId, workspaceId);
@@ -741,7 +780,8 @@ exports.ThreadService = ThreadService;
 exports.ThreadService = ThreadService = ThreadService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(3, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [thread_repository_js_1.ThreadRepository,
         crewx_pool_service_js_1.CrewxPoolService,
-        task_repository_js_1.TaskRepository, Object])
+        task_repository_js_1.TaskRepository, Object, thread_label_service_js_1.ThreadLabelService])
 ], ThreadService);

package/dist-server/main.js

@@ -53,6 +53,7 @@ const auth_constants_js_1 = require("./domain/auth/auth.constants.js");
 const ip_utils_js_1 = require("./domain/auth/utils/ip.utils.js");
 const project_repository_js_1 = require("./repository/project.repository.js");
 const browser_open_js_1 = require("./bootstrap/browser-open.js");
+const validation_pipe_js_1 = require("./common/validation.pipe.js");
 async function bootstrap() {
     const httpsOptions = await (0, tls_js_1.resolveHttpsOptions)();
     // RT-6: bodyParser disabled to preserve raw body for adapter webhook signature verification.
@@ -110,7 +111,7 @@ async function bootstrap() {
         exposedHeaders: ['Mcp-Session-Id'],
     });
     // Enable class-validator DTO validation
-    app.useGlobalPipes(new common_1.ValidationPipe({ whitelist: true, transform: true }));
+    app.useGlobalPipes((0, validation_pipe_js_1.createServerValidationPipe)());
     // Global prefix for API routes (exclude MCP and auth login/logout — they live at /mcp, /auth/*)
     app.setGlobalPrefix('api/v1', {
         exclude: [

package/dist-server/repository/repository.module.js

@@ -18,6 +18,7 @@ const usage_limit_snapshot_repository_js_1 = require("./usage-limit-snapshot.rep
 const usage_report_repository_js_1 = require("./usage-report.repository.js");
 const notification_repository_js_1 = require("./notification.repository.js");
 const agent_suggestion_repository_js_1 = require("./agent-suggestion.repository.js");
+const thread_label_repository_js_1 = require("./thread-label.repository.js");
 const repositories = [
     thread_repository_js_1.ThreadRepository,
     task_repository_js_1.TaskRepository,
@@ -29,6 +30,7 @@ const repositories = [
     usage_report_repository_js_1.UsageReportRepository,
     notification_repository_js_1.NotificationRepository,
     agent_suggestion_repository_js_1.AgentSuggestionRepository,
+    thread_label_repository_js_1.ThreadLabelRepository,
 ];
 let RepositoryModule = class RepositoryModule {
 };

package/dist-server/repository/thread-label.repository.js

@@ -0,0 +1,79 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadLabelRepository = void 0;
+exports.threadLabelGroup = threadLabelGroup;
+const common_1 = require("@nestjs/common");
+const repository_1 = require("@crewx/sdk/repository");
+const GLOBAL_LOOKUP_WORKSPACE = '__crewx_global_lookup__';
+function threadLabelGroup(kind) {
+    return kind === 'state' ? 'THREAD_STATE' : 'THREAD_PRIORITY';
+}
+/**
+ * Server adapter around the SDK common-code repository.
+ *
+ * The adapter translates feature terminology (`state`/`priority`) to SDK
+ * groups. It deliberately does not own a second group list, palette, or SQL
+ * implementation of common-code rules.
+ */
+let ThreadLabelRepository = class ThreadLabelRepository {
+    sdkRepository;
+    constructor(sdkRepository) {
+        this.sdkRepository = sdkRepository ?? new repository_1.CommonCodeRepository();
+    }
+    list(kind, workspaceId, includeArchived) {
+        const group = threadLabelGroup(kind);
+        const lookupWorkspace = workspaceId || GLOBAL_LOOKUP_WORKSPACE;
+        return includeArchived
+            ? this.sdkRepository.listForHistory(group, lookupWorkspace)
+            : this.sdkRepository.listSelectable(group, lookupWorkspace);
+    }
+    resolve(kind, code, workspaceId) {
+        const row = this.sdkRepository.resolve(threadLabelGroup(kind), code);
+        if (!row)
+            return null;
+        if (row.workspace_id !== null && row.workspace_id !== (workspaceId ?? ''))
+            return null;
+        return row;
+    }
+    findByName(kind, name, workspaceId) {
+        const rows = this.sdkRepository.listForHistory(threadLabelGroup(kind), workspaceId || GLOBAL_LOOKUP_WORKSPACE);
+        const workspaceMatch = workspaceId
+            ? rows.find((row) => row.workspace_id === workspaceId && row.code_name === name)
+            : undefined;
+        return workspaceMatch
+            ?? rows.find((row) => row.workspace_id === null && row.code_name === name)
+            ?? null;
+    }
+    createState(workspaceId, name, color) {
+        return this.sdkRepository.createThreadState({ workspaceId, name, color });
+    }
+    update(kind, code, workspaceId, input) {
+        return this.sdkRepository.updateDisplay({
+            group: threadLabelGroup(kind),
+            code,
+            workspaceId,
+            ...input,
+        });
+    }
+    archive(kind, code, workspaceId, archived) {
+        return this.sdkRepository.archive(threadLabelGroup(kind), code, workspaceId, archived);
+    }
+};
+exports.ThreadLabelRepository = ThreadLabelRepository;
+exports.ThreadLabelRepository = ThreadLabelRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [repository_1.CommonCodeRepository])
+], ThreadLabelRepository);

package/dist-server/repository/thread.repository.js

@@ -13,6 +13,10 @@ const drizzle_orm_1 = require("drizzle-orm");
 const repository_1 = require("@crewx/sdk/repository");
 const base_sqlite_repository_js_1 = require("./base-sqlite.repository.js");
 const thread_title_types_js_1 = require("../domain/thread/thread-title.types.js");
+const THREAD_STATE_INDEX_EXPR = "json_extract(metadata, '$.threadTitle.state')";
+const THREAD_PRIORITY_INDEX_EXPR = "json_extract(metadata, '$.threadTitle.priority')";
+const THREAD_STATE_INDEX = 'idx_threads_workspace_thread_state';
+const THREAD_PRIORITY_INDEX = 'idx_threads_workspace_thread_priority';
 let ThreadRepository = class ThreadRepository extends base_sqlite_repository_js_1.BaseSqliteRepository {
     sdkThread = new repository_1.ThreadRepository();
     /** Fetch all threads from all DB paths, deduplicated by id.
@@ -28,6 +32,99 @@ let ThreadRepository = class ThreadRepository extends base_sqlite_repository_js_
             throw e;
         }
     }
+    /**
+     * Query exact metadata values through the same JSON expressions used by the
+     * SDK-owned expression indexes. The in-memory list path remains the fallback
+     * for unscoped legacy callers; HTTP workspace requests always provide an id.
+     */
+    findAllThreadsByTitleFilters(workspaceId, filters) {
+        if (!workspaceId) {
+            const rows = this.findAllThreads(workspaceId);
+            return rows.filter((row) => {
+                const state = this.readRawThreadTitleValue(row.metadata, 'state');
+                const priority = this.readRawThreadTitleValue(row.metadata, 'priority');
+                return this.matchesRawFilter(state, filters.state) && this.matchesRawFilter(priority, filters.priority);
+            });
+        }
+        const query = this.buildThreadTitleFilterQuery(workspaceId, filters);
+        const seenIds = new Set();
+        const result = [];
+        for (const dbPath of this.resolveDbPaths()) {
+            if (!(0, fs_1.existsSync)(dbPath))
+                continue;
+            const handle = (0, repository_1.openDrizzleDb)(dbPath);
+            try {
+                for (const row of handle.db.all(query)) {
+                    if (seenIds.has(row.id))
+                        continue;
+                    seenIds.add(row.id);
+                    result.push(row);
+                }
+            }
+            finally {
+                handle.close();
+            }
+        }
+        return result;
+    }
+    /** Test/diagnostic plan for the exact THD.LIST title-filter SQL. */
+    explainThreadTitleFilterPlan(workspaceId, filters) {
+        const query = this.buildThreadTitleFilterQuery(workspaceId, filters);
+        for (const dbPath of this.resolveDbPaths()) {
+            if (!(0, fs_1.existsSync)(dbPath))
+                continue;
+            const handle = (0, repository_1.openDrizzleDb)(dbPath);
+            try {
+                return handle.db.all((0, drizzle_orm_1.sql) `EXPLAIN QUERY PLAN ${query}`).map((row) => row.detail);
+            }
+            finally {
+                handle.close();
+            }
+        }
+        return [];
+    }
+    buildThreadTitleFilterQuery(workspaceId, filters) {
+        const clauses = [(0, drizzle_orm_1.sql) `workspace_id = ${workspaceId}`];
+        if (filters.state)
+            clauses.push(this.buildRawFilterSql(THREAD_STATE_INDEX_EXPR, filters.state));
+        if (filters.priority)
+            clauses.push(this.buildRawFilterSql(THREAD_PRIORITY_INDEX_EXPR, filters.priority));
+        const index = filters.state ? THREAD_STATE_INDEX : filters.priority ? THREAD_PRIORITY_INDEX : undefined;
+        const indexedTable = index
+            ? (0, drizzle_orm_1.sql) `threads INDEXED BY ${drizzle_orm_1.sql.raw(index)}`
+            : (0, drizzle_orm_1.sql) `threads`;
+        return (0, drizzle_orm_1.sql) `SELECT * FROM ${indexedTable} WHERE ${drizzle_orm_1.sql.join(clauses, (0, drizzle_orm_1.sql) ` AND `)} ORDER BY updated_at DESC`;
+    }
+    buildRawFilterSql(expression, filter) {
+        const expressionSql = drizzle_orm_1.sql.raw(expression);
+        const valuesSql = filter.values.length > 0
+            ? (0, drizzle_orm_1.sql) `${expressionSql} IN (${drizzle_orm_1.sql.join(filter.values.map((value) => (0, drizzle_orm_1.sql) `${value}`), (0, drizzle_orm_1.sql) `, `)})`
+            : undefined;
+        if (filter.includeNone && valuesSql)
+            return (0, drizzle_orm_1.sql) `(${valuesSql} OR ${expressionSql} IS NULL)`;
+        if (filter.includeNone)
+            return (0, drizzle_orm_1.sql) `${expressionSql} IS NULL`;
+        return valuesSql ?? (0, drizzle_orm_1.sql) `1 = 1`;
+    }
+    readRawThreadTitleValue(metadata, key) {
+        if (!metadata)
+            return null;
+        try {
+            const root = JSON.parse(metadata);
+            const value = root.threadTitle?.[key];
+            return typeof value === 'string' ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    matchesRawFilter(value, filter) {
+        if (!filter)
+            return true;
+        if (value === null)
+            return filter.includeNone;
+        return filter.values.includes(value);
+    }
     /** Find only the threads whose id or title exactly matches one of `ids`.
      *  Avoids loading the entire threads table for scoped lookups (WI-20260718-001). */
     findThreadsByIdsOrTitles(ids, workspaceId) {
@@ -189,6 +286,13 @@ let ThreadRepository = class ThreadRepository extends base_sqlite_repository_js_
             handle.close();
         }
     }
+    /** Delegate metadata writes to the SDK's atomic read/merge/write patch. */
+    patchThreadTitleMetadata(threadId, patch, workspaceId) {
+        const result = this.sdkThread.patchThreadTitleMetadata(threadId, patch, workspaceId);
+        if (result instanceof repository_1.ThreadTitleMetadataPatchError)
+            throw result;
+        return result;
+    }
     /** Toggle pinned 0↔1 for a thread. Returns new state or null if not found. */
     togglePin(threadId, workspaceId) {
         try {

package/dist-server/shared/thread-label.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Transport-only contract for conversation state and priority labels.
+ *
+ * This file intentionally has no Nest, Node, database, or SDK dependency so
+ * browser clients can reuse the wire shape without pulling server code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewx",
-  "version": "0.9.0-rc.73",
+  "version": "0.9.0-rc.74",
   "description": "CrewX — AI agent team dashboard with Electron UI and CLI (Web + Electron + Global CLI)",
   "main": "server.js",
   "bin": {
@@ -82,20 +82,20 @@
     "wink-nlp-utils": "2.1.0",
     "yargs": "17.7.0",
     "zod": "3.25.76",
-    "@crewx/chromex": "0.1.0-rc.105",
-    "@crewx/cli": "0.9.0-rc.73",
-    "@crewx/cron": "0.1.10-rc.107",
-    "@crewx/dreaming": "0.1.0-rc.98",
-    "@crewx/doc": "0.1.9-rc.65",
-    "@crewx/knowledge-core": "0.1.17-rc.82",
-    "@crewx/memory": "0.1.23-rc.89",
+    "@crewx/chromex": "0.1.0-rc.106",
+    "@crewx/cron": "0.1.10-rc.108",
+    "@crewx/cli": "0.9.0-rc.74",
+    "@crewx/dreaming": "0.1.0-rc.99",
+    "@crewx/doc": "0.1.9-rc.66",
+    "@crewx/memory": "0.1.23-rc.90",
+    "@crewx/sdk": "0.9.0-rc.74",
     "@crewx/shared": "0.0.6",
-    "@crewx/sdk": "0.9.0-rc.73",
-    "@crewx/search": "0.1.10-rc.68",
     "@crewx/skill": "0.1.20",
-    "@crewx/wbs": "0.1.10-rc.98",
-    "@crewx/wi": "0.1.10-rc.93",
-    "@crewx/workflow": "0.3.22-rc.119"
+    "@crewx/knowledge-core": "0.1.17-rc.83",
+    "@crewx/search": "0.1.10-rc.69",
+    "@crewx/workflow": "0.3.22-rc.120",
+    "@crewx/wi": "0.1.10-rc.94",
+    "@crewx/wbs": "0.1.10-rc.99"
   },
   "devDependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.132",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.9.0-rc.73",
+  "version": "0.9.0-rc.74",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"