fission-worker 0.2.2 → 0.3.0

package/runner/modules/pipeline/pipeline-worker.service.js

@@ -0,0 +1,343 @@
+"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); }
+};
+var PipelineWorkerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineWorkerService = void 0;
+const common_1 = require("@nestjs/common");
+const common_2 = require("@nestjs/common");
+const pipeline_helpers_service_1 = require("./pipeline-helpers.service");
+let PipelineWorkerService = PipelineWorkerService_1 = class PipelineWorkerService {
+    data;
+    helpers;
+    logger = new common_1.Logger(PipelineWorkerService_1.name);
+    /** Persistent Claude session IDs per worker slot — reuse context across tasks. */
+    slotSessions = new Map();
+    constructor(data, helpers) {
+        this.data = data;
+        this.helpers = helpers;
+    }
+    /** Clear all persistent sessions (call between pipeline runs). */
+    clearSessions() {
+        this.slotSessions.clear();
+    }
+    // ------------------------------------------------------------------ //
+    //  Build Agent — builds a task, marks IN_REVIEW if diff exists        //
+    // ------------------------------------------------------------------ //
+    async runBuildAgent(task, projectId, repoPaths, repoPath, sessionId, projectContext, slot = 0) {
+        const MAX_RETRIES = 3;
+        // Check retry limit BEFORE doing any work
+        if (task.retryCount >= MAX_RETRIES) {
+            this.logger.warn(`[${sessionId}] Task "${task.title}" exceeded max retries (${task.retryCount}/${MAX_RETRIES}) — marking FAILED`);
+            await this.data.updateTask(task.id, { status: "FAILED" });
+            await this.data.createTaskComment({
+                taskId: task.id,
+                author: "worker",
+                content: `Max retries exceeded (${task.retryCount}/${MAX_RETRIES}). Task permanently failed.`,
+            });
+            this.data.emit(projectId, "task_updated", { id: task.id, status: "FAILED" });
+            return;
+        }
+        // Track what this worker slot is doing
+        this.helpers.workerTasks.set(slot, task.title);
+        this.helpers.emitAgentState(projectId);
+        // Capture git HEAD before worker starts (stored in metadata for QA later)
+        let preWorkerHead;
+        try {
+            preWorkerHead = this.helpers.gitRevParse(repoPath);
+        }
+        catch { }
+        // Move to IN_PROGRESS
+        await this.data.updateTask(task.id, { status: "IN_PROGRESS" });
+        await this.data.createTaskComment({
+            taskId: task.id,
+            author: "worker",
+            content: `Started working on this task (attempt ${task.retryCount + 1}/${MAX_RETRIES})`,
+        });
+        this.data.emit(projectId, "task_updated", { id: task.id, status: "IN_PROGRESS" });
+        this.data.emit(projectId, "build_progress", { taskId: task.id, taskTitle: task.title, status: "starting" });
+        this.logger.log(`[${sessionId}] Worker: building "${task.title}" (attempt ${task.retryCount + 1}/${MAX_RETRIES})`);
+        try {
+            // Fetch task comment history so the worker has full context
+            const taskComments = await this.data.findTaskComments(task.id, {
+                orderBy: { createdAt: "asc" },
+                take: 20,
+            });
+            const commentHistory = taskComments.length > 0
+                ? `\nTask history (read carefully — includes QA feedback and previous attempts):\n${taskComments.map((c) => `[${c.author}]: ${c.content}`).join("\n")}\n`
+                : "";
+            const workerPrompt = (projectContext ? `Project context:\n${projectContext}\n\n` : "") +
+                `You are a developer. Implement this task: ${task.title}. ` +
+                `Objective: ${task.objective || "No additional details."}. ` +
+                commentHistory +
+                `The project has the following repositories:\n${repoPaths}\n\n` +
+                `Decide which repo(s) to work in based on the task. Make the changes, then commit with a descriptive message. ` +
+                `Report what you did as JSON with fields: summary (string), filesChanged (string array). ` +
+                `Return ONLY valid JSON.`;
+            // Effort-based timeout (generous — Claude needs time for context + plan + implement + commit)
+            const taskTimeout = task.effort === "small"
+                ? 10 * 60 * 1000 // 10 minutes
+                : task.effort === "large"
+                    ? 30 * 60 * 1000 // 30 minutes
+                    : 15 * 60 * 1000; // 15 minutes (medium default)
+            // Use persistent session: resume if this slot already has a session, otherwise start new
+            const existingSession = this.slotSessions.get(slot);
+            const workerResult = await this.helpers.spawnClaude(workerPrompt, repoPath, undefined, taskTimeout, { projectId, phase: "BUILD" }, { resumeSessionId: existingSession, jsonOutput: true });
+            // Capture session ID for future tasks in this slot
+            if (workerResult.sessionId) {
+                this.slotSessions.set(slot, workerResult.sessionId);
+            }
+            const workerOutput = this.helpers.parseClaudeJson(workerResult.stdout);
+            if (workerResult.exitCode === 0) {
+                // Check if worker actually produced a diff
+                let postWorkerHead;
+                let hasDiff = false;
+                if (preWorkerHead) {
+                    try {
+                        postWorkerHead = this.helpers.gitRevParse(repoPath);
+                        hasDiff = preWorkerHead !== postWorkerHead;
+                    }
+                    catch { }
+                }
+                if (!hasDiff) {
+                    // No diff — check if worker actually failed despite exit code 0
+                    const summaryText = workerOutput?.summary ?? workerResult.stdout.slice(0, 2000);
+                    const failureIndicators = ["unable to", "could not", "blocked", "not applied", "not granted", "were denied", "was denied", "permission"];
+                    const workerActuallyFailed = failureIndicators.some((indicator) => summaryText.toLowerCase().includes(indicator));
+                    if (workerActuallyFailed) {
+                        const updatedTask = await this.data.updateTask(task.id, {
+                            status: (task.retryCount + 1) >= 3 ? "FAILED" : "READY_TO_START",
+                            retryCount: { increment: 1 },
+                            metadata: (workerOutput ?? { rawOutput: summaryText }),
+                        });
+                        await this.data.createTaskComment({
+                            taskId: task.id,
+                            author: "worker",
+                            content: `Failed (no code changes made, attempt ${task.retryCount + 1}/3): ${summaryText.slice(0, 300)}`,
+                        });
+                        this.data.emit(projectId, "task_updated", { id: task.id, status: updatedTask.status });
+                    }
+                    else {
+                        // Genuinely completed without code changes (e.g., investigation task)
+                        await this.data.updateTask(task.id, {
+                            status: "COMPLETED",
+                            metadata: (workerOutput ?? { rawOutput: workerResult.stdout.slice(0, 2000) }),
+                        });
+                        await this.data.createTaskComment({
+                            taskId: task.id,
+                            author: "worker",
+                            content: workerOutput?.summary
+                                ? `Completed: ${workerOutput.summary}${workerOutput.filesChanged ? `\nFiles changed: ${workerOutput.filesChanged.join(", ")}` : ""}`
+                                : `Task completed (exit code: ${workerResult.exitCode})`,
+                        });
+                        this.data.emit(projectId, "task_updated", { id: task.id, status: "COMPLETED" });
+                    }
+                }
+                else {
+                    // Has diff — move to IN_REVIEW and store heads for QA to pick up later
+                    await this.data.updateTask(task.id, {
+                        status: "IN_REVIEW",
+                        metadata: {
+                            ...(workerOutput ?? { rawOutput: workerResult.stdout.slice(0, 2000) }),
+                            preWorkerHead,
+                            postWorkerHead,
+                            repoPath,
+                        },
+                    });
+                    await this.data.createTaskComment({
+                        taskId: task.id,
+                        author: "worker",
+                        content: workerOutput?.summary
+                            ? `Build complete, awaiting QA: ${workerOutput.summary}${workerOutput.filesChanged ? `\nFiles changed: ${workerOutput.filesChanged.join(", ")}` : ""}`
+                            : `Build complete (exit code: ${workerResult.exitCode}), awaiting QA review.`,
+                    });
+                    this.data.emit(projectId, "task_updated", { id: task.id, status: "IN_REVIEW" });
+                }
+            }
+            else {
+                // Non-zero exit code — increment retry count and decide status
+                const newRetryCount = task.retryCount + 1;
+                const finalStatus = newRetryCount >= MAX_RETRIES ? "FAILED" : "READY_TO_START";
+                await this.data.updateTask(task.id, {
+                    status: finalStatus,
+                    retryCount: { increment: 1 },
+                    metadata: (workerOutput ?? { rawOutput: workerResult.stdout.slice(0, 2000) }),
+                });
+                await this.data.createTaskComment({
+                    taskId: task.id,
+                    author: "worker",
+                    content: newRetryCount >= MAX_RETRIES
+                        ? `Failed (exit code: ${workerResult.exitCode}). Max retries exceeded (${newRetryCount}/${MAX_RETRIES}). Task permanently failed.`
+                        : `Failed (exit code: ${workerResult.exitCode}). Retry ${newRetryCount}/${MAX_RETRIES} — sent back to Ready to Start.`,
+                });
+                this.data.emit(projectId, "task_updated", { id: task.id, status: finalStatus });
+            }
+            this.data.emit(projectId, "build_progress", {
+                taskId: task.id,
+                taskTitle: task.title,
+                status: workerResult.exitCode === 0 ? "done" : "failed",
+            });
+        }
+        catch (err) {
+            this.logger.warn(`Worker failed on task "${task.title}": ${err}`);
+            const newRetryCount = task.retryCount + 1;
+            const finalStatus = newRetryCount >= MAX_RETRIES ? "FAILED" : "READY_TO_START";
+            await this.data.updateTask(task.id, {
+                status: finalStatus,
+                retryCount: { increment: 1 },
+                metadata: { error: String(err) },
+            });
+            await this.data.createTaskComment({
+                taskId: task.id,
+                author: "worker",
+                content: newRetryCount >= MAX_RETRIES
+                    ? `Failed: ${String(err) || "Unknown error"}. Max retries exceeded (${newRetryCount}/${MAX_RETRIES}). Task permanently failed.`
+                    : `Failed: ${String(err) || "Unknown error"}. Retry ${newRetryCount}/${MAX_RETRIES} — sent back to Ready to Start.`,
+            });
+            this.data.emit(projectId, "task_updated", { id: task.id, status: finalStatus });
+            this.data.emit(projectId, "build_progress", {
+                taskId: task.id,
+                taskTitle: task.title,
+                status: "failed",
+            });
+        }
+        finally {
+            // Clear worker slot tracking
+            this.helpers.workerTasks.delete(slot);
+        }
+    }
+    // ------------------------------------------------------------------ //
+    //  QA Agent — reviews an IN_REVIEW task (decoupled from build)        //
+    // ------------------------------------------------------------------ //
+    async runQaAgent(task, projectId, repoPath, slot = 0) {
+        const MAX_RETRIES = 3;
+        this.helpers.workerTasks.set(slot, `QA: ${task.title}`);
+        this.helpers.emitAgentState(projectId);
+        try {
+            // Read diff heads from task metadata (stored by build agent)
+            const meta = task.metadata || {};
+            const preHead = meta.preWorkerHead;
+            const postHead = meta.postWorkerHead;
+            const taskRepoPath = meta.repoPath || repoPath;
+            let diffForReview = "";
+            if (preHead && postHead) {
+                diffForReview = this.helpers.gitDiff(taskRepoPath, preHead, postHead);
+            }
+            if (!diffForReview) {
+                // No diff available — approve by default
+                this.logger.warn(`[QA] No diff found for task "${task.title}" — approving by default`);
+                await this.data.updateTask(task.id, { status: "COMPLETED" });
+                await this.data.createTaskComment({
+                    taskId: task.id,
+                    author: "qa-agent",
+                    content: "QA approved (no diff available for review).",
+                });
+                this.data.emit(projectId, "task_updated", { id: task.id, status: "COMPLETED" });
+                return;
+            }
+            // Run QA review
+            const qaPrompt = `You are a QA reviewer. Review this code change for task: "${task.title}"\n` +
+                `Objective: ${task.objective || "N/A"}\n\n` +
+                `Git diff:\n${diffForReview.slice(0, 10000)}\n\n` +
+                `Check for: bugs, missing error handling, security issues, incomplete implementation.\n` +
+                `Return JSON: {approved: boolean, summary: string, issues: string[]}\n` +
+                `ONLY valid JSON.`;
+            const qaResult = await this.helpers.spawnClaude(qaPrompt, taskRepoPath, "claude-sonnet-4-6", 5 * 60 * 1000, { projectId, phase: "REVIEW" });
+            const qaOutput = this.helpers.parseClaudeJson(qaResult.stdout);
+            let qaApproved = true;
+            let qaSummary = "";
+            let qaIssues = [];
+            if (qaOutput && typeof qaOutput.approved === "boolean") {
+                qaApproved = qaOutput.approved;
+                qaSummary = qaOutput.summary || "";
+                qaIssues = qaOutput.issues || [];
+            }
+            this.data.emit(projectId, "qa_review", { taskId: task.id, approved: qaApproved, issues: qaIssues });
+            if (qaApproved) {
+                await this.data.updateTask(task.id, { status: "COMPLETED" });
+                await this.data.createTaskComment({
+                    taskId: task.id,
+                    author: "qa-agent",
+                    content: `QA approved. ${qaSummary}`,
+                });
+                this.data.emit(projectId, "task_updated", { id: task.id, status: "COMPLETED" });
+            }
+            else {
+                // QA rejected — send back to developer
+                const newRetryCount = task.retryCount + 1;
+                const finalStatus = newRetryCount >= MAX_RETRIES ? "FAILED" : "READY_TO_START";
+                await this.data.updateTask(task.id, {
+                    status: finalStatus,
+                    retryCount: { increment: 1 },
+                });
+                await this.data.createTaskComment({
+                    taskId: task.id,
+                    author: "qa-agent",
+                    content: `QA rejected (attempt ${task.retryCount + 1}/${MAX_RETRIES}). ${qaSummary}\nIssues:\n${qaIssues.map((i) => `- ${i}`).join("\n")}`,
+                });
+                this.data.emit(projectId, "task_updated", { id: task.id, status: finalStatus });
+            }
+        }
+        catch (qaErr) {
+            // QA agent failure — approve by default so pipeline isn't blocked
+            this.logger.warn(`QA agent failed for task "${task.title}": ${qaErr} — approving by default`);
+            await this.data.updateTask(task.id, { status: "COMPLETED" });
+            await this.data.createTaskComment({
+                taskId: task.id,
+                author: "qa-agent",
+                content: `QA agent error — approved by default. Error: ${String(qaErr).slice(0, 200)}`,
+            });
+            this.data.emit(projectId, "task_updated", { id: task.id, status: "COMPLETED" });
+        }
+        finally {
+            this.helpers.workerTasks.delete(slot);
+        }
+    }
+    // ------------------------------------------------------------------ //
+    //  Replan — archive failed task, reset finding to NEW for Tech Lead   //
+    // ------------------------------------------------------------------ //
+    async replanFailedTask(task) {
+        // Archive the failed task
+        await this.data.updateTask(task.id, { status: "ARCHIVED" });
+        if (task.findingId) {
+            // Reset linked finding to NEW so Tech Lead re-plans it
+            await this.data.updateFinding(task.findingId, { status: "NEW" });
+        }
+        else {
+            // No linked finding — create one from the task
+            await this.data.createFinding({
+                projectId: task.projectId,
+                title: task.title,
+                description: task.objective || `Re-plan failed task: ${task.title}`,
+                severity: "MEDIUM",
+                category: "FEATURE",
+                status: "NEW",
+                source: "replan",
+            });
+        }
+        await this.data.createTaskComment({
+            taskId: task.id,
+            author: "pipeline",
+            content: "Auto-replanned: task archived, finding sent back to Tech Lead for re-assessment.",
+        });
+        this.data.emit(task.projectId, "task_updated", { id: task.id, status: "ARCHIVED" });
+        this.logger.log(`[Replan] Task "${task.title}" archived and finding reset to NEW`);
+    }
+};
+exports.PipelineWorkerService = PipelineWorkerService;
+exports.PipelineWorkerService = PipelineWorkerService = PipelineWorkerService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_2.Optional)()),
+    __param(0, (0, common_2.Inject)("PIPELINE_DATA")),
+    __metadata("design:paramtypes", [Object, pipeline_helpers_service_1.PipelineHelpersService])
+], PipelineWorkerService);

package/runner/modules/pipeline/pipeline.controller.js

@@ -0,0 +1,310 @@
+"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); }
+};
+var PipelineController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineController = void 0;
+const common_1 = require("@nestjs/common");
+const jwt_1 = require("@nestjs/jwt");
+const config_1 = require("@nestjs/config");
+const throttler_1 = require("@nestjs/throttler");
+const client_1 = require("@prisma/client");
+const roles_decorator_1 = require("../../common/decorators/roles.decorator");
+const current_user_decorator_1 = require("../../common/decorators/current-user.decorator");
+const public_decorator_1 = require("../../common/decorators/public.decorator");
+const event_bus_service_1 = require("../../common/services/event-bus.service");
+const pipeline_service_1 = require("./pipeline.service");
+const pipeline_queue_service_1 = require("./pipeline-queue.service");
+let PipelineController = PipelineController_1 = class PipelineController {
+    pipelineService;
+    pipelineQueueService;
+    eventBus;
+    jwtService;
+    configService;
+    logger = new common_1.Logger(PipelineController_1.name);
+    constructor(pipelineService, pipelineQueueService, eventBus, jwtService, configService) {
+        this.pipelineService = pipelineService;
+        this.pipelineQueueService = pipelineQueueService;
+        this.eventBus = eventBus;
+        this.jwtService = jwtService;
+        this.configService = configService;
+    }
+    /** GET /pipeline/queue/status — global queue status (must be before :projectId routes). */
+    async getQueueStatus() {
+        return { data: this.pipelineQueueService.getStatus() };
+    }
+    /** GET /pipeline/agents — current agent state derived from DB (persistent, accurate). */
+    async getAgentState() {
+        return { data: await this.pipelineService.getAgentStateFromDb() };
+    }
+    /** GET /pipeline/history — paginated history of all pipeline sessions. */
+    async getPipelineHistory(projectId, page, limit) {
+        return this.pipelineService.getPipelineHistory({
+            projectId: projectId || undefined,
+            page: parseInt(page || "1", 10) || 1,
+            limit: parseInt(limit || "20", 10) || 20,
+        });
+    }
+    /**
+     * GET /pipeline/:projectId/events?token=<jwt> — SSE stream for real-time
+     * kanban updates. Auth is via query param because EventSource does not
+     * support custom headers.
+     *
+     * Marked @Public() to bypass the global JwtAuthGuard (we validate the
+     * token manually from the query string).
+     */
+    async events(projectId, token, reply) {
+        // --- Manual JWT validation ---
+        if (!token) {
+            throw new common_1.UnauthorizedException("Missing token query parameter");
+        }
+        try {
+            const secret = this.configService.getOrThrow("ACCESS_JWT_SECRET");
+            this.jwtService.verify(token, { secret });
+        }
+        catch {
+            throw new common_1.UnauthorizedException("Invalid or expired token");
+        }
+        // --- Stream SSE via raw Node response ---
+        const raw = reply.raw;
+        raw.setHeader("Content-Type", "text/event-stream");
+        raw.setHeader("Cache-Control", "no-cache");
+        raw.setHeader("Connection", "keep-alive");
+        raw.setHeader("X-Accel-Buffering", "no"); // disable nginx buffering
+        raw.flushHeaders();
+        // Send an initial comment to confirm connection
+        raw.write(": connected\n\n");
+        // Keep-alive ping every 30 seconds so proxies don't close idle connections
+        const keepAlive = setInterval(() => {
+            raw.write(": ping\n\n");
+        }, 30_000);
+        // Subscribe to the event bus
+        const subscription = this.eventBus.getStream(projectId).subscribe({
+            next: (event) => {
+                raw.write(`data: ${event.data}\n\n`);
+            },
+            error: (err) => {
+                this.logger.error(`SSE stream error for project ${projectId}: ${err}`);
+                raw.end();
+            },
+        });
+        // Clean up when the client disconnects
+        raw.on("close", () => {
+            clearInterval(keepAlive);
+            subscription.unsubscribe();
+            this.logger.debug(`SSE client disconnected for project ${projectId}`);
+        });
+    }
+    /** POST /pipeline/:projectId/autopilot — toggle autopilot mode. */
+    async toggleAutopilot(projectId, enabled) {
+        await this.pipelineService.setAutopilot(projectId, enabled);
+        return { data: { enabled } };
+    }
+    /** GET /pipeline/:projectId/autopilot — get autopilot status. */
+    async getAutopilot(projectId) {
+        const enabled = await this.pipelineService.isAutopilotEnabled(projectId);
+        return { data: { enabled } };
+    }
+    /** POST /pipeline/:projectId/run — start the R&D pipeline (background). */
+    async runPipeline(projectId, userId) {
+        const result = await this.pipelineService.runPipeline(projectId, userId);
+        return { data: result };
+    }
+    /** POST /pipeline/:projectId/stop — stop the running pipeline. */
+    async stopPipeline(projectId, userId) {
+        const result = await this.pipelineService.stopPipeline(projectId, userId);
+        return { data: result };
+    }
+    /** POST /pipeline/:projectId/direction — send user direction to the pipeline. */
+    async sendDirection(projectId, direction, userId) {
+        if (!direction || typeof direction !== "string") {
+            throw new common_1.BadRequestException("Direction is required");
+        }
+        // Strip control characters (keep newlines and tabs for readability)
+        const sanitized = direction.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").trim();
+        if (!sanitized) {
+            throw new common_1.BadRequestException("Direction must not be empty");
+        }
+        if (sanitized.length > 500) {
+            throw new common_1.BadRequestException("Direction must be 500 characters or fewer");
+        }
+        const result = await this.pipelineService.sendDirection(projectId, sanitized, userId);
+        return { data: result };
+    }
+    /** POST /pipeline/:projectId/sync — sync docs/rnd/ to DB. */
+    async syncPipelineState(projectId) {
+        const result = await this.pipelineService.syncPipelineState(projectId);
+        return { data: result };
+    }
+    /** GET /pipeline/:projectId/sessions — get active sessions. */
+    async getActiveSessions(projectId) {
+        return this.pipelineService.getActiveSessions(projectId);
+    }
+    /** GET /pipeline/:projectId/sessions/:sessionId — get session detail with phase info. */
+    async getSession(sessionId) {
+        return this.pipelineService.getSession(sessionId);
+    }
+    /** GET /pipeline/:projectId/sessions/:sessionId/diff — get diff from worker phase. */
+    async getSessionDiff(sessionId) {
+        const result = await this.pipelineService.getSessionDiff(sessionId);
+        return { data: result };
+    }
+    /** GET /pipeline/:projectId/sessions/:sessionId/summary — get pipeline run summary. */
+    async getSessionSummary(sessionId) {
+        const result = await this.pipelineService.getSessionSummary(sessionId);
+        return { data: result };
+    }
+    /** POST /pipeline/:projectId/command — run arbitrary claude -p command. */
+    async runCommand(projectId, prompt, userId) {
+        const result = await this.pipelineService.runCommand(projectId, prompt, userId);
+        return { data: result };
+    }
+};
+exports.PipelineController = PipelineController;
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)("queue/status"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getQueueStatus", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)("agents"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getAgentState", null);
+__decorate([
+    (0, common_1.Get)("history"),
+    __param(0, (0, common_1.Query)("projectId")),
+    __param(1, (0, common_1.Query)("page")),
+    __param(2, (0, common_1.Query)("limit")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getPipelineHistory", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/events"),
+    (0, public_decorator_1.Public)(),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, common_1.Query)("token")),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "events", null);
+__decorate([
+    (0, common_1.Post)(":projectId/autopilot"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, common_1.Body)("enabled")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "toggleAutopilot", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/autopilot"),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getAutopilot", null);
+__decorate([
+    (0, common_1.Post)(":projectId/run"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, current_user_decorator_1.CurrentUser)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "runPipeline", null);
+__decorate([
+    (0, common_1.Post)(":projectId/stop"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, current_user_decorator_1.CurrentUser)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "stopPipeline", null);
+__decorate([
+    (0, common_1.Post)(":projectId/direction"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, common_1.Body)("direction")),
+    __param(2, (0, current_user_decorator_1.CurrentUser)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "sendDirection", null);
+__decorate([
+    (0, common_1.Post)(":projectId/sync"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "syncPipelineState", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/sessions"),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getActiveSessions", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/sessions/:sessionId"),
+    __param(0, (0, common_1.Param)("sessionId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getSession", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/sessions/:sessionId/diff"),
+    __param(0, (0, common_1.Param)("sessionId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getSessionDiff", null);
+__decorate([
+    (0, throttler_1.SkipThrottle)({ global: true }),
+    (0, common_1.Get)(":projectId/sessions/:sessionId/summary"),
+    __param(0, (0, common_1.Param)("sessionId", common_1.ParseUUIDPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "getSessionSummary", null);
+__decorate([
+    (0, common_1.Post)(":projectId/command"),
+    (0, roles_decorator_1.Roles)(client_1.Role.ADMIN),
+    __param(0, (0, common_1.Param)("projectId", common_1.ParseUUIDPipe)),
+    __param(1, (0, common_1.Body)("prompt")),
+    __param(2, (0, current_user_decorator_1.CurrentUser)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], PipelineController.prototype, "runCommand", null);
+exports.PipelineController = PipelineController = PipelineController_1 = __decorate([
+    (0, common_1.Controller)("pipeline"),
+    __metadata("design:paramtypes", [pipeline_service_1.PipelineService,
+        pipeline_queue_service_1.PipelineQueueService,
+        event_bus_service_1.EventBusService,
+        jwt_1.JwtService,
+        config_1.ConfigService])
+], PipelineController);