crewx 0.9.0-rc.2 → 0.9.0-rc.21

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

@@ -44,11 +44,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SettingsService = void 0;
 const fs_1 = require("fs");
+const node_path_1 = require("node:path");
 const common_1 = require("@nestjs/common");
 const yaml = __importStar(require("js-yaml"));
+const knowledge_core_1 = require("@crewx/knowledge-core");
 const analytics_client_js_1 = require("../../common/analytics.client.js");
 const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
 const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
+const DEFAULT_OVERDRIVE_TURNS = 3;
+// wbs defaults — mirrors packages/built-in/wbs/src/engine.ts:58-78 (getSourceBranch/getTargetBranch/getMergeStrategy)
+const DEFAULT_WBS_SOURCE_BRANCH = 'auto';
+const DEFAULT_WBS_TARGET_BRANCH = 'auto';
+const DEFAULT_WBS_MERGE_STRATEGY = 'local';
+// memory defaults — mirrors packages/built-in/memory/src/engine.ts:130-163 (MemoryEngine constructor)
+const DEFAULT_MEMORY_SUMMARY_DAYS = 7;
+const DEFAULT_MEMORY_RECENT_DAYS = 30;
+const DEFAULT_MEMORY_SHORT_TERM_HOURS = 24;
+const DEFAULT_MEMORY_SUMMARIZER_AGENT = '@memory_summarizer';
+const DEFAULT_MEMORY_SEARCHER_AGENT = '@memory_searcher';
+const DEFAULT_MEMORY_SUMMARIZER_TIMEOUT = 60000;
+const DEFAULT_MEMORY_SEARCHER_TIMEOUT = 300000;
+// workflow defaults — mirrors packages/built-in/workflow/cli.ts:88-97 (getWorkflowConfig)
+const DEFAULT_WORKFLOW_PATHS = ['workflows'];
 let SettingsService = class SettingsService {
     analyticsService;
     pool;
@@ -57,17 +74,28 @@ let SettingsService = class SettingsService {
         this.pool = pool;
     }
     get configPath() {
-        return this.pool.resolveConfigPath((0, workspace_context_store_js_1.getWorkspacePath)()) ?? 'crewx.yaml';
+        const workspacePath = (0, workspace_context_store_js_1.getWorkspacePath)();
+        return this.pool.resolveConfigPath(workspacePath) ?? (0, node_path_1.join)(workspacePath, 'crewx.yaml');
     }
     getSettings() {
         const config = this.loadConfig();
         const settings = (config.settings ?? {});
         const dreaming = (settings.dreaming ?? {});
         const continuity = (dreaming.continuity ?? {});
+        const overdrive = (settings.overdrive ?? {});
         const template = (settings.template ?? {});
         const exec = (template.exec ?? {});
+        const wbs = (settings.wbs ?? {});
+        const docs = (settings.docs ?? {});
+        const search = (settings.search ?? {});
+        const searchCache = (search.cache ?? {});
+        const memory = (settings.memory ?? {});
+        const workflow = (settings.workflow ?? {});
         return {
             analytics: settings.analytics !== false,
+            overdrive: {
+                defaultTurns: this.normalizeOverdriveTurns(overdrive.defaultTurns),
+            },
             continuity: {
                 lookback: typeof continuity.lookback === 'number' ? continuity.lookback : 3,
                 reuseReadOnly: continuity.reuseReadOnly !== false,
@@ -86,6 +114,36 @@ let SettingsService = class SettingsService {
                 timeout: typeof exec.timeout === 'number' ? exec.timeout : 30,
                 allow: Array.isArray(exec.allow) ? exec.allow : [],
             },
+            wbs: {
+                sourceBranch: typeof wbs.source_branch === 'string' ? wbs.source_branch : DEFAULT_WBS_SOURCE_BRANCH,
+                targetBranch: typeof wbs.target_branch === 'string' ? wbs.target_branch : DEFAULT_WBS_TARGET_BRANCH,
+                mergeStrategy: wbs.merge_strategy === 'pr' ? 'pr' : DEFAULT_WBS_MERGE_STRATEGY,
+            },
+            docs: {
+                extraRoots: Array.isArray(docs.extra_roots) ? docs.extra_roots : [],
+                rootFiles: Array.isArray(docs.root_files) ? docs.root_files : [...knowledge_core_1.DEFAULT_ROOT_FILES],
+                exclude: Array.isArray(docs.exclude) ? docs.exclude : [...knowledge_core_1.DEFAULT_EXCLUDE],
+            },
+            search: {
+                cache: {
+                    ttl: typeof searchCache.ttl === 'number' ? searchCache.ttl : knowledge_core_1.DEFAULT_SEARCH_CONFIG.cache.ttl,
+                    max: typeof searchCache.max === 'number' ? searchCache.max : knowledge_core_1.DEFAULT_SEARCH_CONFIG.cache.max,
+                },
+            },
+            memory: {
+                summaryDays: typeof memory.summary_days === 'number' ? memory.summary_days : DEFAULT_MEMORY_SUMMARY_DAYS,
+                recentDays: typeof memory.recent_days === 'number' ? memory.recent_days : DEFAULT_MEMORY_RECENT_DAYS,
+                shortTermHours: typeof memory.short_term_hours === 'number' ? memory.short_term_hours : DEFAULT_MEMORY_SHORT_TERM_HOURS,
+                summarizerAgent: typeof memory.summarizer_agent === 'string' ? memory.summarizer_agent : DEFAULT_MEMORY_SUMMARIZER_AGENT,
+                searcherAgent: typeof memory.searcher_agent === 'string' ? memory.searcher_agent : DEFAULT_MEMORY_SEARCHER_AGENT,
+                summarizerTimeout: typeof memory.summarizer_timeout === 'number'
+                    ? memory.summarizer_timeout
+                    : DEFAULT_MEMORY_SUMMARIZER_TIMEOUT,
+                searcherTimeout: typeof memory.searcher_timeout === 'number' ? memory.searcher_timeout : DEFAULT_MEMORY_SEARCHER_TIMEOUT,
+            },
+            workflow: {
+                paths: Array.isArray(workflow.paths) ? workflow.paths : [...DEFAULT_WORKFLOW_PATHS],
+            },
         };
     }
     updateSettings(patch) {
@@ -160,6 +218,130 @@ let SettingsService = class SettingsService {
             }
             dirty = true;
         }
+        if (patch.overdrive !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.overdrive || typeof settings.overdrive !== 'object') {
+                settings.overdrive = {};
+            }
+            const overdrive = settings.overdrive;
+            if (patch.overdrive.defaultTurns !== undefined) {
+                const val = patch.overdrive.defaultTurns;
+                if (Number.isInteger(val) && val > 0) {
+                    overdrive.defaultTurns = val;
+                }
+            }
+            dirty = true;
+        }
+        if (patch.wbs !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.wbs || typeof settings.wbs !== 'object') {
+                settings.wbs = {};
+            }
+            const wbs = settings.wbs;
+            if (patch.wbs.sourceBranch !== undefined) {
+                wbs.source_branch = patch.wbs.sourceBranch;
+            }
+            if (patch.wbs.targetBranch !== undefined) {
+                wbs.target_branch = patch.wbs.targetBranch;
+            }
+            if (patch.wbs.mergeStrategy !== undefined) {
+                wbs.merge_strategy = patch.wbs.mergeStrategy;
+            }
+            dirty = true;
+        }
+        if (patch.docs !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.docs || typeof settings.docs !== 'object') {
+                settings.docs = {};
+            }
+            const docs = settings.docs;
+            if (patch.docs.extraRoots !== undefined) {
+                docs.extra_roots = patch.docs.extraRoots;
+            }
+            if (patch.docs.rootFiles !== undefined) {
+                docs.root_files = patch.docs.rootFiles;
+            }
+            if (patch.docs.exclude !== undefined) {
+                docs.exclude = patch.docs.exclude;
+            }
+            dirty = true;
+        }
+        if (patch.search?.cache !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.search || typeof settings.search !== 'object') {
+                settings.search = {};
+            }
+            const search = settings.search;
+            if (!search.cache || typeof search.cache !== 'object') {
+                search.cache = {};
+            }
+            const cache = search.cache;
+            if (patch.search.cache.ttl !== undefined) {
+                cache.ttl = patch.search.cache.ttl;
+            }
+            if (patch.search.cache.max !== undefined) {
+                cache.max = patch.search.cache.max;
+            }
+            dirty = true;
+        }
+        if (patch.memory !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.memory || typeof settings.memory !== 'object') {
+                settings.memory = {};
+            }
+            const memory = settings.memory;
+            if (patch.memory.summaryDays !== undefined) {
+                memory.summary_days = patch.memory.summaryDays;
+            }
+            if (patch.memory.recentDays !== undefined) {
+                memory.recent_days = patch.memory.recentDays;
+            }
+            if (patch.memory.shortTermHours !== undefined) {
+                memory.short_term_hours = patch.memory.shortTermHours;
+            }
+            if (patch.memory.summarizerAgent !== undefined) {
+                memory.summarizer_agent = patch.memory.summarizerAgent;
+            }
+            if (patch.memory.searcherAgent !== undefined) {
+                memory.searcher_agent = patch.memory.searcherAgent;
+            }
+            if (patch.memory.summarizerTimeout !== undefined) {
+                memory.summarizer_timeout = patch.memory.summarizerTimeout;
+            }
+            if (patch.memory.searcherTimeout !== undefined) {
+                memory.searcher_timeout = patch.memory.searcherTimeout;
+            }
+            dirty = true;
+        }
+        if (patch.workflow !== undefined) {
+            if (!config.settings || typeof config.settings !== 'object') {
+                config.settings = {};
+            }
+            const settings = config.settings;
+            if (!settings.workflow || typeof settings.workflow !== 'object') {
+                settings.workflow = {};
+            }
+            const workflow = settings.workflow;
+            if (patch.workflow.paths !== undefined) {
+                workflow.paths = patch.workflow.paths;
+            }
+            dirty = true;
+        }
         if (dirty) {
             this.saveConfig(config);
             if (analyticsValue !== undefined) {
@@ -168,6 +350,11 @@ let SettingsService = class SettingsService {
         }
         return this.getSettings();
     }
+    normalizeOverdriveTurns(value) {
+        return Number.isInteger(value) && value > 0
+            ? value
+            : DEFAULT_OVERDRIVE_TURNS;
+    }
     loadConfig() {
         if (!(0, fs_1.existsSync)(this.configPath))
             return {};

package/dist-server/domain/system/system.controller.js

@@ -0,0 +1,41 @@
+"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.SystemController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+let SystemController = class SystemController {
+    shutdown() {
+        // Delay the signal to the next tick so the 202 response reaches the
+        // client before shutdown begins. Send SIGTERM to self instead of
+        // process.exit(0) so Nest's shutdown hooks (enableShutdownHooks in
+        // main.ts) run and onApplicationShutdown -> crewx.close() can clean up
+        // active tasks gracefully. forceCloseConnections (see main.ts) forces
+        // any lingering keep-alive/SSE connections closed once the process exits.
+        setTimeout(() => {
+            process.kill(process.pid, 'SIGTERM');
+        }, 100);
+        return { success: true, data: { message: 'Server is shutting down' } };
+    }
+};
+exports.SystemController = SystemController;
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'SYS.SHUTDOWN', summary: 'Shut down the server' }),
+    (0, common_1.Post)('shutdown'),
+    (0, common_1.HttpCode)(202),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], SystemController.prototype, "shutdown", null);
+exports.SystemController = SystemController = __decorate([
+    (0, swagger_1.ApiTags)('system'),
+    (0, common_1.Controller)('system')
+], SystemController);

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

@@ -0,0 +1,19 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemModule = void 0;
+const common_1 = require("@nestjs/common");
+const system_controller_js_1 = require("./system.controller.js");
+let SystemModule = class SystemModule {
+};
+exports.SystemModule = SystemModule;
+exports.SystemModule = SystemModule = __decorate([
+    (0, common_1.Module)({
+        controllers: [system_controller_js_1.SystemController],
+    })
+], SystemModule);

package/dist-server/domain/task/task.constants.js

@@ -1,5 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_TASK_LOG_LIMIT = exports.DEFAULT_TASK_LOG_LIMIT = void 0;
+exports.OWNED_PROCESS_MARKERS = exports.MAX_TASK_LOG_LIMIT = exports.DEFAULT_TASK_LOG_LIMIT = void 0;
 exports.DEFAULT_TASK_LOG_LIMIT = 1000;
 exports.MAX_TASK_LOG_LIMIT = 1000;
+/**
+ * Markers used to verify a PID is owned by a crewx-spawned process before
+ * sending it a kill signal. This is a safety check against PID reuse — it is
+ * NOT a provider whitelist. Any provider CLI that crewx can spawn must have
+ * its command name (or a wrapper token) listed here.
+ */
+exports.OWNED_PROCESS_MARKERS = ['crewx', 'claude', 'codex', 'opencode', 'node'];

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

@@ -22,6 +22,7 @@ const sdk_1 = require("@crewx/sdk");
 const task_repository_js_1 = require("../../repository/task.repository.js");
 const project_repository_js_1 = require("../../repository/project.repository.js");
 const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
+const stdout_json_fallback_js_1 = require("../../common/task-log/stdout-json-fallback.js");
 const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
 const MAX_LOG_ENTRY_FIELD_LEN = 128 * 1024; // 128KB worth of UTF-16 code units
 const RUNNING_INSTRUCTION_SYSTEM_MESSAGE = '<crewx_system_message type="running_instruction">\n' +
@@ -140,7 +141,7 @@ let TaskService = TaskService_1 = class TaskService {
         // PID ownership verification: ensure PID belongs to a crewx-related process
         try {
             const cmdOutput = (0, child_process_1.execSync)(`ps -p ${task.pid} -o command=`, { encoding: 'utf-8', timeout: 3000 }).trim();
-            if (!cmdOutput.includes('crewx') && !cmdOutput.includes('claude') && !cmdOutput.includes('node')) {
+            if (!this.isOwnedProcess(cmdOutput)) {
                 throw new common_1.HttpException({ code: 'PID_NOT_FOUND', message: 'Process ID not found' }, 422);
             }
         }
@@ -200,10 +201,12 @@ let TaskService = TaskService_1 = class TaskService {
         }
         const metadata = this.parseTaskMetadata(task.metadata);
         const provider = this.extractProviderFromMeta(task.metadata);
+        const wasOverdrive = metadata.overdrive === true;
+        const overdriveState = metadata.overdriveState === 'latch' ? 'latch' : 'count';
         const providerSessionId = this.readString(metadata.provider_session_id)
             ?? this.readString(metadata.providerSessionId)
             ?? this.extractProviderSessionIdFromLogs(task.logs);
-        if (!provider || (provider !== 'cli/codex' && provider !== 'cli/claude')) {
+        if (!provider || (provider !== 'cli/codex' && provider !== 'cli/claude' && provider !== 'cli/opencode')) {
             throw new common_1.HttpException({ code: 'PROVIDER_UNSUPPORTED', message: 'Provider does not support running instructions' }, 422);
         }
         if (!providerSessionId) {
@@ -242,6 +245,7 @@ let TaskService = TaskService_1 = class TaskService {
             threadId,
             taskId,
             provider,
+            model: task.model ?? undefined,
             platform: 'cli',
             resumeSessionId: providerSessionId,
             metadata: {
@@ -250,6 +254,11 @@ let TaskService = TaskService_1 = class TaskService {
                 provider,
                 provider_session_id: providerSessionId,
                 runningInstruction: instruction,
+                ...(wasOverdrive ? {
+                    overdrive: true,
+                    overdriveState,
+                    overdriveMode: 'execute',
+                } : {}),
                 // Tags this run's task:end so finishTask only closes the matching
                 // generation, ignoring the killed prior run's stale task:end.
                 runEpoch,
@@ -257,6 +266,15 @@ let TaskService = TaskService_1 = class TaskService {
             cwd: (0, workspace_context_store_js_1.getWorkspacePath)(),
         }).catch((err) => {
             this.logger.error(`Running instruction resume failed [task=${taskId}]: ${err.message}`, err.stack);
+            // Safety net: if execute() rejected before the new process ever reported
+            // its pid (task:start), the row would be a permanent zombie
+            // (status=running, pid=NULL). Only transition to failed if the row is
+            // still exactly in that pending-resume state — if a new process already
+            // reported its pid, or a later instruction bumped run_epoch again, this
+            // is a no-op so we never clobber a task that already recovered.
+            if (runEpoch != null) {
+                this.taskRepo.markTaskFailedIfResumePending(taskId, runEpoch, `Running instruction resume failed: ${err.message}`, workspaceId);
+            }
         });
         return { taskId, status: 'running', agentId: task.agent_id, resumedFromTaskId: taskId };
     }
@@ -445,7 +463,7 @@ let TaskService = TaskService_1 = class TaskService {
         }
         const adapterKey = this.extractAdapterKey(row);
         if (wantLogs) {
-            result.logs = this.parseLogs(row.logs, logLimit, adapterKey);
+            result.logs = this.parseLogs(row.logs, logLimit, adapterKey).logs;
         }
         result.toolUsage = this.aggregateToolUsage(row.logs, adapterKey);
         if (wantChildren) {
@@ -493,7 +511,7 @@ let TaskService = TaskService_1 = class TaskService {
     }
     // --- TSK005 private helpers ---
     toChildTaskStatus(row) {
-        const logs = this.parseLogs(row.logs, 1, this.extractAdapterKey(row));
+        const { logs } = this.parseLogs(row.logs, 1, this.extractAdapterKey(row));
         return {
             taskId: row.id,
             agentId: row.agent_id,
@@ -515,19 +533,19 @@ let TaskService = TaskService_1 = class TaskService {
             return undefined;
         }
     }
-    /** @see ThreadService.parseLogs — 동일 역할, ACP 파싱 로직 동기화 필요 */
+    /** @see ThreadService.parseLogs — 동일 역할, ACP 파싱 로직 동기화 필요 (TSK.GET 응답에는 progressSteps 미포함) */
     parseLogs(logsJson, logLimit, providerId) {
         if (!logsJson)
-            return [];
+            return { logs: [], progressSteps: [] };
         let rawLogs;
         try {
             rawLogs = JSON.parse(logsJson);
         }
         catch {
-            return [];
+            return { logs: [], progressSteps: [] };
         }
         if (!Array.isArray(rawLogs))
-            return [];
+            return { logs: [], progressSteps: [] };
         const entries = [];
         for (const log of rawLogs) {
             if (log.level === 'stdout') {
@@ -539,7 +557,7 @@ let TaskService = TaskService_1 = class TaskService {
                     }
                     // Parsed successfully but no displayable entries (e.g. thinking-only assistant message).
                     // Skip fallback if the raw message is a known metadata-only stream-json event type.
-                    if (this.shouldSkipRawStdoutJsonFallback(log.message))
+                    if ((0, stdout_json_fallback_js_1.shouldSkipRawStdoutJsonFallback)(log.message, providerId))
                         continue;
                 }
                 catch { /* adapter parse failure — fallback to text */ }
@@ -555,18 +573,17 @@ let TaskService = TaskService_1 = class TaskService {
                 }
             }
         }
-        // Pipeline: merge consecutive text → deduplicate tool_use → truncate → logLimit slice
+        // Pipeline: merge consecutive text → deduplicate tool_use → truncate → [branch: text-only slice(-200) = progressSteps] → logLimit slice = logs
         const merged = this.mergeConsecutiveText(entries);
         const deduped = this.deduplicateToolUse(merged);
         const truncated = deduped.map((e) => this.truncateEntry(e));
+        const progressSteps = truncated.filter((e) => e.type === 'text').slice(-200);
         // Return the latest N entries (trim from the beginning)
-        if (truncated.length > logLimit) {
-            return truncated.slice(truncated.length - logLimit);
-        }
-        return truncated;
+        const logs = truncated.length > logLimit ? truncated.slice(truncated.length - logLimit) : truncated;
+        return { logs, progressSteps };
     }
     aggregateToolUsage(logsJson, providerId) {
-        const entries = this.parseLogs(logsJson, task_constants_js_1.MAX_TASK_LOG_LIMIT, providerId);
+        const { logs: entries } = this.parseLogs(logsJson, task_constants_js_1.MAX_TASK_LOG_LIMIT, providerId);
         const counts = new Map();
         for (const entry of entries) {
             if (entry.type === 'tool_use' && entry.toolName) {
@@ -639,6 +656,11 @@ let TaskService = TaskService_1 = class TaskService {
                 if (claudeSessionId) {
                     return claudeSessionId;
                 }
+                // OpenCode: every event carries a top-level `sessionID` (e.g. step_start/tool_use/text).
+                const opencodeSessionId = this.readString(message.sessionID);
+                if (opencodeSessionId) {
+                    return opencodeSessionId;
+                }
             }
             catch {
                 // Ignore non-JSON log lines.
@@ -674,6 +696,9 @@ let TaskService = TaskService_1 = class TaskService {
                 if (providerKey === 'codex' && this.isCodexResumableEvent(message)) {
                     return true;
                 }
+                if (providerKey === 'opencode' && this.isOpencodeResumableEvent(message)) {
+                    return true;
+                }
             }
             catch {
                 // Ignore non-JSON log lines.
@@ -681,6 +706,18 @@ let TaskService = TaskService_1 = class TaskService {
         }
         return false;
     }
+    isOpencodeResumableEvent(message) {
+        const type = typeof message.type === 'string' ? message.type : '';
+        if (type === 'tool_use') {
+            return true;
+        }
+        if (type === 'text') {
+            const part = message.part;
+            const text = part?.text;
+            return typeof text === 'string' && text.trim().length > 0;
+        }
+        return false;
+    }
     isClaudeResumableEvent(message) {
         if (message.type !== 'assistant') {
             return false;
@@ -717,13 +754,18 @@ let TaskService = TaskService_1 = class TaskService {
         }
         return false;
     }
+    /** PID ownership check: is this `ps -o command=` output a process we're allowed to kill?
+     *  Guards against PID reuse — NOT a provider whitelist (see OWNED_PROCESS_MARKERS doc). */
+    isOwnedProcess(cmdOutput) {
+        return task_constants_js_1.OWNED_PROCESS_MARKERS.some((marker) => cmdOutput.includes(marker));
+    }
     terminateRunningProcess(task) {
         if (task.pid == null) {
             throw new common_1.HttpException({ code: 'PID_NOT_FOUND', message: 'Process ID not found' }, 422);
         }
         try {
             const cmdOutput = (0, child_process_1.execSync)(`ps -p ${task.pid} -o command=`, { encoding: 'utf-8', timeout: 3000 }).trim();
-            if (!cmdOutput.includes('crewx') && !cmdOutput.includes('claude') && !cmdOutput.includes('codex') && !cmdOutput.includes('node')) {
+            if (!this.isOwnedProcess(cmdOutput)) {
                 throw new common_1.HttpException({ code: 'PID_NOT_FOUND', message: 'Process ID not found' }, 422);
             }
         }
@@ -868,7 +910,7 @@ let TaskService = TaskService_1 = class TaskService {
             // Merge logs from all matching tasks
             const allLogs = [];
             for (const task of matchingTasks) {
-                const parsed = this.parseLogs(task.logs, 100, this.extractAdapterKey(task));
+                const { logs: parsed } = this.parseLogs(task.logs, 100, this.extractAdapterKey(task));
                 allLogs.push(...parsed);
             }
             // Sort by timestamp
@@ -971,56 +1013,6 @@ let TaskService = TaskService_1 = class TaskService {
             return text;
         return text.slice(0, maxLen) + '...';
     }
-    /**
-     * Returns true when the raw stdout line is a known metadata-only JSON event that
-     * should be silently dropped rather than shown as raw text.
-     *
-     * Covers Claude, Codex, and OpenCode stream-json protocols.
-     * Only called after parseStdoutEvent() returns [] (no displayable entries).
-     * Partial / truncated JSON → JSON.parse throws → returns false (keep raw text fallback).
-     */
-    shouldSkipRawStdoutJsonFallback(message) {
-        const trimmed = message.trimStart();
-        if (!trimmed.startsWith('{'))
-            return false;
-        let obj;
-        try {
-            obj = JSON.parse(trimmed);
-        }
-        catch {
-            return false;
-        }
-        const type = obj.type;
-        if (typeof type !== 'string')
-            return false;
-        // Claude stream-json metadata events
-        if (type === 'assistant' ||
-            type === 'user' ||
-            type === 'system' ||
-            type === 'result' ||
-            type === 'rate_limit_event') {
-            return true;
-        }
-        // Codex metadata-only events
-        if (type === 'thread.started' ||
-            type === 'turn.started' ||
-            type === 'turn.completed' ||
-            type === 'turn.failed' ||
-            type === 'item.updated') {
-            return true;
-        }
-        // Codex item.started/item.completed reach this function only after
-        // parseStdoutEvent() returned no displayable entries. Skip raw fallback while
-        // preserving the original line in tasks.logs for future reprocessing.
-        if (type === 'item.started' || type === 'item.completed') {
-            return true;
-        }
-        // OpenCode metadata-only events
-        if (type === 'step_start' || type === 'step_finish') {
-            return true;
-        }
-        return false;
-    }
     normalizeLimit(limit, fallback, max) {
         const num = Number(limit);
         if (!Number.isFinite(num) || num <= 0)

package/dist-server/domain/thread/dto/list-threads.dto.js

@@ -22,6 +22,7 @@ class ListThreadsDto {
     order;
     limit;
     offset;
+    pinnedFirst;
 }
 exports.ListThreadsDto = ListThreadsDto;
 __decorate([
@@ -68,3 +69,20 @@ __decorate([
     (0, class_validator_1.IsNumber)(),
     __metadata("design:type", Number)
 ], ListThreadsDto.prototype, "offset", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'Whether pinned threads are always shown first, unaffected by pagination (default: true)',
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if (typeof value === 'boolean')
+            return value;
+        if (value === 'false')
+            return false;
+        if (value === 'true')
+            return true;
+        return value;
+    }),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], ListThreadsDto.prototype, "pinnedFirst", void 0);

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

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Overdrive (부스트/각성 모드) state model.
+ *
+ * User-facing term: Boost / 부스트 / 갉성 모드
+ * Internal key:    overdrive
+ *
+ * The overdrive state is stored under `thread.metadata.overdrive`. Web chat
+ * uses the count state as a multi-request boost; CLI flags can still trigger a
+ * single boosted request without requiring a persistent UI session.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OVERDRIVE_DEFAULT_TURNS = void 0;
+exports.parseOverdriveSummary = parseOverdriveSummary;
+const DEFAULT_TURNS = 3;
+/** Parse a raw thread metadata blob into a normalized OverdriveSummary. */
+function parseOverdriveSummary(metadataJson) {
+    if (!metadataJson) {
+        return { state: 'off', remaining: 0 };
+    }
+    try {
+        const meta = JSON.parse(metadataJson);
+        const od = meta?.overdrive;
+        if (!od || typeof od !== 'object') {
+            return { state: 'off', remaining: 0 };
+        }
+        const state = (od.state ?? 'off');
+        const remaining = typeof od.remaining === 'number' ? od.remaining : 0;
+        if (state === 'count' && remaining <= 0) {
+            return { state: 'off', remaining: 0 };
+        }
+        return { state, remaining };
+    }
+    catch {
+        return { state: 'off', remaining: 0 };
+    }
+}
+exports.OVERDRIVE_DEFAULT_TURNS = DEFAULT_TURNS;