fission-worker 0.2.1 → 0.3.0

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

@@ -0,0 +1,706 @@
+"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 PipelineService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineService = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const prisma_service_1 = require("../../prisma/prisma.service");
+const activity_log_service_1 = require("../../common/services/activity-log.service");
+const event_bus_service_1 = require("../../common/services/event-bus.service");
+const common_2 = require("@nestjs/common");
+const pipeline_orchestrator_1 = require("./pipeline-orchestrator");
+const pipeline_queue_service_1 = require("./pipeline-queue.service");
+const pipeline_helpers_service_1 = require("./pipeline-helpers.service");
+const pipeline_cto_service_1 = require("./pipeline-cto.service");
+const pipeline_techlead_service_1 = require("./pipeline-techlead.service");
+const pipeline_worker_service_1 = require("./pipeline-worker.service");
+const worker_dispatch_service_1 = require("../worker-api/worker-dispatch.service");
+/** Max age for cached project context before it is regenerated. */
+const CONTEXT_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
+let PipelineService = PipelineService_1 = class PipelineService {
+    prisma;
+    activityLog;
+    eventBus;
+    data;
+    pipelineQueue;
+    helpers;
+    ctoService;
+    techLeadService;
+    workerService;
+    workerDispatch;
+    logger = new common_1.Logger(PipelineService_1.name);
+    activeProcesses = new Map();
+    /** Set of session IDs with a pending stop request. */
+    stopRequested = new Set();
+    /** Track which projects have an active autopilot loop (projectId → running). */
+    autopilotLoops = new Map();
+    /** System user ID used for autopilot and other non-user-initiated sessions. */
+    systemUserId = "";
+    constructor(prisma, activityLog, eventBus, data, pipelineQueue, helpers, ctoService, techLeadService, workerService, workerDispatch) {
+        this.prisma = prisma;
+        this.activityLog = activityLog;
+        this.eventBus = eventBus;
+        this.data = data;
+        this.pipelineQueue = pipelineQueue;
+        this.helpers = helpers;
+        this.ctoService = ctoService;
+        this.techLeadService = techLeadService;
+        this.workerService = workerService;
+        this.workerDispatch = workerDispatch;
+    }
+    async onModuleInit() {
+        // Upsert a system user for autopilot and other non-user-initiated sessions
+        const systemUser = await this.prisma.user.upsert({
+            where: { email: "system@fission.internal" },
+            update: {},
+            create: {
+                email: "system@fission.internal",
+                name: "System",
+                passwordHash: "not-a-real-hash",
+                role: "ADMIN",
+                isActive: false, // can't login
+            },
+        });
+        this.systemUserId = systemUser.id;
+        // Cleanup orphaned sessions from previous crashes/restarts
+        const orphaned = await this.prisma.session.updateMany({
+            where: { status: { in: ["ACTIVE", "QUEUED"] } },
+            data: { status: "TERMINATED", endedAt: new Date() },
+        });
+        if (orphaned.count > 0) {
+            this.logger.warn(`Cleaned up ${orphaned.count} orphaned session(s) from previous run`);
+        }
+        // Cleanup stuck tasks — send IN_PROGRESS back to READY_TO_START
+        const stuckInProgress = await this.prisma.task.updateMany({
+            where: { status: "IN_PROGRESS" },
+            data: { status: "READY_TO_START" },
+        });
+        if (stuckInProgress.count > 0) {
+            this.logger.warn(`Sent ${stuckInProgress.count} stuck IN_PROGRESS task(s) back to READY_TO_START`);
+        }
+        // Move any legacy PLANNING tasks to READY_TO_START (PLANNING is now a finding status)
+        const stuckPlanning = await this.prisma.task.updateMany({
+            where: { status: "PLANNED" },
+            data: { status: "READY_TO_START" },
+        });
+        if (stuckPlanning.count > 0) {
+            this.logger.warn(`Moved ${stuckPlanning.count} PLANNED task(s) to READY_TO_START`);
+        }
+        // Register the callback the queue uses to start the next pipeline
+        this.pipelineQueue.onStartNext((entry) => {
+            this.startPipelineExecution(entry.sessionId, entry.projectId, entry.repoPath, entry.userId).catch((err) => this.logger.error(`Pipeline ${entry.sessionId} unexpected error: ${err}`));
+        });
+        // Start worker health check (marks stale workers offline, re-queues orphaned sessions)
+        setInterval(() => {
+            this.workerDispatch.checkWorkerHealth().catch((err) => this.logger.warn(`Worker health check failed: ${err}`));
+        }, 60_000);
+        // Resume autopilot for projects that had it enabled before restart
+        const autopilotProjects = await this.prisma.project.findMany({
+            where: { settings: { path: ["autopilot"], equals: true } },
+        });
+        for (const project of autopilotProjects) {
+            const repos = await this.prisma.repository.findMany({ where: { projectId: project.id } });
+            if (repos.length > 0) {
+                this.logger.log(`[Autopilot] Resuming autopilot for project ${project.id} (${project.name})`);
+                this.startAutopilot(project.id);
+            }
+        }
+    }
+    async onApplicationShutdown(signal) {
+        const activeCount = this.activeProcesses.size;
+        if (activeCount === 0) {
+            this.logger.log('No active pipelines — shutting down immediately');
+            return;
+        }
+        this.logger.log(`Received ${signal ?? 'shutdown signal'} — waiting for ${activeCount} active pipeline(s) to complete before shutdown...`);
+        // Wait for all active processes to finish (no timeout — always wait)
+        await Promise.all(Array.from(this.activeProcesses.entries()).map(([sessionId, proc]) => {
+            return new Promise((resolve) => {
+                if (proc.exitCode !== null) {
+                    resolve();
+                    return;
+                }
+                proc.on('close', () => {
+                    this.logger.log(`Pipeline ${sessionId} completed during shutdown`);
+                    resolve();
+                });
+                proc.on('error', () => resolve());
+            });
+        }));
+        this.logger.log('All pipelines completed — shutdown proceeding');
+    }
+    // ------------------------------------------------------------------ //
+    //  Pipeline history                                                   //
+    // ------------------------------------------------------------------ //
+    async getPipelineHistory(params) {
+        const page = Math.max(1, params.page ?? 1);
+        const limit = Math.min(100, Math.max(1, params.limit ?? 20));
+        const skip = (page - 1) * limit;
+        const where = {};
+        if (params.projectId)
+            where.projectId = params.projectId;
+        const [sessions, total] = await Promise.all([
+            this.prisma.session.findMany({
+                where,
+                orderBy: { startedAt: "desc" },
+                skip,
+                take: limit,
+                include: {
+                    project: { select: { id: true, name: true } },
+                },
+            }),
+            this.prisma.session.count({ where }),
+        ]);
+        // For each session, count findings and tasks created during its lifetime
+        const data = await Promise.all(sessions.map(async (session) => {
+            const phaseCompleteLogs = await this.prisma.activityLog.findMany({
+                where: {
+                    entityType: "Session",
+                    entityId: session.id,
+                    action: "PIPELINE_PHASE_COMPLETE",
+                },
+                select: { details: true },
+            });
+            let findingsCount = 0;
+            let tasksCount = 0;
+            for (const log of phaseCompleteLogs) {
+                const details = log.details;
+                if (details) {
+                    if (typeof details.findingsCreated === "number") {
+                        findingsCount += details.findingsCreated;
+                    }
+                    if (typeof details.tasksCreated === "number") {
+                        tasksCount += details.tasksCreated;
+                    }
+                }
+            }
+            return {
+                ...session,
+                findingsCreated: findingsCount,
+                tasksCreated: tasksCount,
+            };
+        }));
+        return {
+            data,
+            meta: {
+                total,
+                page,
+                limit,
+                totalPages: Math.ceil(total / limit),
+            },
+        };
+    }
+    // ------------------------------------------------------------------ //
+    //  Run an arbitrary claude -p command                                  //
+    // ------------------------------------------------------------------ //
+    async runCommand(projectId, prompt, userId) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        if (!project)
+            throw new common_1.NotFoundException("Project not found");
+        const repos = await this.prisma.repository.findMany({ where: { projectId } });
+        const cwd = repos.length > 0 ? repos[0].repoPath : process.cwd();
+        const { stdout, stderr, exitCode } = await this.helpers.spawnClaude(prompt, cwd);
+        const output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
+        await this.activityLog.log("PIPELINE_COMMAND", "Project", projectId, userId, { prompt, exitCode, outputLength: output.length });
+        return { output, exitCode };
+    }
+    // ------------------------------------------------------------------ //
+    //  Run the full R&D pipeline (background — returns immediately)       //
+    // ------------------------------------------------------------------ //
+    async runPipeline(projectId, userId) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        if (!project)
+            throw new common_1.NotFoundException("Project not found");
+        const repos = await this.prisma.repository.findMany({ where: { projectId } });
+        const primaryRepoPath = repos.length > 0 ? repos[0].repoPath : process.cwd();
+        // Create the session with QUEUED status initially
+        const session = await this.prisma.session.create({
+            data: {
+                projectId,
+                userId: userId ?? this.systemUserId,
+                status: "QUEUED",
+                phase: "QUEUED",
+            },
+        });
+        await this.activityLog.log("PIPELINE_START", "Session", session.id, userId, { projectId });
+        // Try to dispatch to a remote worker first
+        const worker = await this.workerDispatch.findWorker(projectId, userId ?? this.systemUserId);
+        if (worker) {
+            await this.prisma.session.update({
+                where: { id: session.id },
+                data: { status: "DISPATCHED", workerId: worker.id },
+            });
+            await this.prisma.worker.update({
+                where: { id: worker.id },
+                data: { activeSessions: { increment: 1 } },
+            });
+            this.logger.log(`[${session.id}] Dispatched to worker "${worker.name}" (${worker.id.slice(0, 8)})`);
+            return { sessionId: session.id, message: `Dispatched to worker "${worker.name}"`, position: 0 };
+        }
+        // No worker available — fall back to local execution via queue
+        const { position } = this.pipelineQueue.enqueue({
+            sessionId: session.id,
+            projectId: project.id,
+            userId,
+            repoPath: primaryRepoPath,
+        });
+        if (position === 0) {
+            return { sessionId: session.id, message: "Pipeline started (local)", position: 0 };
+        }
+        return {
+            sessionId: session.id,
+            message: `Queued at position ${position}`,
+            position,
+        };
+    }
+    /**
+     * Called by the queue when it's this session's turn to execute.
+     * Promotes the session from QUEUED to ACTIVE, then runs parallel agents.
+     */
+    async startPipelineExecution(sessionId, projectId, repoPath, userId) {
+        await this.data.updateSession(sessionId, { status: "ACTIVE", phase: "REVIEW" });
+        await this.runParallelAgents(sessionId, projectId, repoPath, userId);
+    }
+    // ------------------------------------------------------------------ //
+    //  Parallel agent orchestrator (runs in background)                   //
+    // ------------------------------------------------------------------ //
+    async runParallelAgents(sessionId, projectId, repoPath, userId) {
+        const repos = await this.prisma.repository.findMany({ where: { projectId } });
+        const repoPaths = repos.length > 0
+            ? repos.map((r) => `${r.name}: ${r.repoPath}`).join("\n")
+            : `Default: ${repoPath}`;
+        const repoList = repos.length > 0
+            ? repos.map((r) => ({ name: r.name, repoPath: r.repoPath }))
+            : [{ name: "default", repoPath }];
+        const projectContext = await this.getOrCreateProjectContext(projectId, repoList);
+        const stopSignal = { stopped: false };
+        // Wire up stop detection
+        const checkStop = setInterval(() => {
+            if (this.stopRequested.has(sessionId))
+                stopSignal.stopped = true;
+        }, 1000);
+        try {
+            await (0, pipeline_orchestrator_1.runPipelineLoop)({
+                data: this.data,
+                helpers: this.helpers,
+                cto: this.ctoService,
+                techLead: this.techLeadService,
+                worker: this.workerService,
+                sessionId,
+                projectId,
+                repoPath,
+                repoPaths,
+                repoList,
+                projectContext,
+                userId,
+                stopSignal,
+            });
+        }
+        finally {
+            clearInterval(checkStop);
+            this.activeProcesses.delete(sessionId);
+            this.stopRequested.delete(sessionId);
+            this.pipelineQueue.dequeue();
+            // Invalidate cached project context so next pipeline run gets fresh data
+            await this.prisma.project.update({
+                where: { id: projectId },
+                data: {
+                    settings: {
+                        ...((await this.prisma.project.findUnique({ where: { id: projectId } }))?.settings || {}),
+                        context: null,
+                        contextGeneratedAt: null,
+                    },
+                },
+            }).catch((err) => this.logger.warn(`Failed to invalidate project context: ${err}`));
+        }
+    }
+    // ------------------------------------------------------------------ //
+    //  Stop a running pipeline                                            //
+    // ------------------------------------------------------------------ //
+    async stopPipeline(projectId, userId) {
+        const sessions = await this.prisma.session.findMany({
+            where: { projectId, status: { in: ["ACTIVE", "QUEUED", "DISPATCHED"] } },
+        });
+        let killed = 0;
+        let dequeued = 0;
+        for (const session of sessions) {
+            if (session.status === "QUEUED") {
+                this.pipelineQueue.cancel(session.id);
+                dequeued++;
+            }
+            else {
+                this.stopRequested.add(session.id);
+                const proc = this.activeProcesses.get(session.id);
+                if (proc) {
+                    proc.kill("SIGTERM");
+                    this.activeProcesses.delete(session.id);
+                    killed++;
+                }
+                this.pipelineQueue.cancel(session.id);
+            }
+            await this.prisma.session.update({
+                where: { id: session.id },
+                data: { status: "TERMINATED", endedAt: new Date() },
+            });
+            await this.activityLog.log("PIPELINE_STOP", "Session", session.id, userId, { reason: "user_requested" });
+        }
+        // Clear stale worker slot tracking and persistent sessions
+        this.helpers.workerTasks.clear();
+        this.helpers.slot3Info = null;
+        this.workerService.clearSessions();
+        return { message: `Stopped ${killed} process(es), removed ${dequeued} from queue` };
+    }
+    // ------------------------------------------------------------------ //
+    //  Autopilot — run pipeline in a continuous loop                      //
+    // ------------------------------------------------------------------ //
+    async setAutopilot(projectId, enabled) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        if (!project)
+            throw new common_1.NotFoundException("Project not found");
+        await this.prisma.project.update({
+            where: { id: projectId },
+            data: {
+                settings: {
+                    ...(project?.settings || {}),
+                    autopilot: enabled,
+                },
+            },
+        });
+        if (enabled) {
+            this.startAutopilot(projectId);
+        }
+        else {
+            this.autopilotLoops.set(projectId, false);
+            await this.stopPipeline(projectId);
+        }
+    }
+    async isAutopilotEnabled(projectId) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        return !!project?.settings?.autopilot;
+    }
+    async startAutopilot(projectId) {
+        if (this.autopilotLoops.get(projectId))
+            return; // already running
+        this.autopilotLoops.set(projectId, true);
+        let consecutiveFailures = 0;
+        const MAX_FAILURES = 3;
+        const COOLDOWN_MS = 30_000;
+        this.logger.log(`[Autopilot] Started for project ${projectId}`);
+        while (this.autopilotLoops.get(projectId)) {
+            try {
+                const enabled = await this.isAutopilotEnabled(projectId);
+                if (!enabled)
+                    break;
+                const result = await this.runPipeline(projectId, this.systemUserId);
+                await this.waitForSessionComplete(result.sessionId);
+                const workDone = await this.prisma.activityLog.count({
+                    where: {
+                        entityId: result.sessionId,
+                        action: { in: ["WORK_COMPLETED", "PIPELINE_FINISH"] },
+                    },
+                });
+                if (workDone > 0) {
+                    consecutiveFailures = 0;
+                }
+                else {
+                    consecutiveFailures++;
+                    this.logger.warn(`[Autopilot] No work done in cycle (failures: ${consecutiveFailures}/${MAX_FAILURES})`);
+                }
+                if (consecutiveFailures >= MAX_FAILURES) {
+                    this.logger.warn(`[Autopilot] Too many consecutive empty cycles, disabling for project ${projectId}`);
+                    await this.setAutopilot(projectId, false);
+                    break;
+                }
+                this.logger.log(`[Autopilot] Cycle complete, cooling down ${COOLDOWN_MS / 1000}s...`);
+                await new Promise((r) => setTimeout(r, COOLDOWN_MS));
+            }
+            catch (err) {
+                this.logger.error(`[Autopilot] Error: ${err}`);
+                consecutiveFailures++;
+                if (consecutiveFailures >= MAX_FAILURES) {
+                    this.logger.warn(`[Autopilot] Too many errors, disabling for project ${projectId}`);
+                    await this.setAutopilot(projectId, false);
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, COOLDOWN_MS));
+            }
+        }
+        this.autopilotLoops.delete(projectId);
+        this.logger.log(`[Autopilot] Stopped for project ${projectId}`);
+    }
+    async waitForSessionComplete(sessionId) {
+        while (true) {
+            const session = await this.prisma.session.findUnique({ where: { id: sessionId } });
+            if (!session || session.status === "TERMINATED")
+                return;
+            await new Promise((r) => setTimeout(r, 5000));
+        }
+    }
+    // ------------------------------------------------------------------ //
+    //  Send a user direction / instruction to the pipeline                //
+    // ------------------------------------------------------------------ //
+    async sendDirection(projectId, direction, userId) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        if (!project)
+            throw new common_1.NotFoundException("Project not found");
+        // Escape HTML/script tags in user input to prevent XSS when rendered
+        const escapedDirection = direction
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+        const finding = await this.prisma.finding.create({
+            data: {
+                projectId,
+                title: escapedDirection.length > 100 ? escapedDirection.slice(0, 100) + "..." : escapedDirection,
+                description: escapedDirection,
+                severity: "MEDIUM",
+                category: "FEATURE",
+                status: "NEW",
+                source: "user-direction",
+            },
+        });
+        await this.activityLog.log("PIPELINE_DIRECTION", "Finding", finding.id, userId, { direction });
+        return { findingId: finding.id, message: "Added to backlog" };
+    }
+    // ------------------------------------------------------------------ //
+    //  Get active pipeline sessions                                       //
+    // ------------------------------------------------------------------ //
+    async getActiveSessions(projectId) {
+        const where = { status: { in: ["ACTIVE", "QUEUED", "DISPATCHED"] } };
+        if (projectId)
+            where.projectId = projectId;
+        const sessions = await this.prisma.session.findMany({
+            where,
+            orderBy: { startedAt: "desc" },
+        });
+        return { data: sessions };
+    }
+    // ------------------------------------------------------------------ //
+    //  Sync docs/rnd/ files to DB (findings + tasks)                      //
+    // ------------------------------------------------------------------ //
+    async syncPipelineState(projectId) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        if (!project)
+            throw new common_1.NotFoundException("Project not found");
+        const repos = await this.prisma.repository.findMany({ where: { projectId } });
+        const primaryRepoPath = repos.length > 0 ? repos[0].repoPath : process.cwd();
+        const rndRoot = (0, path_1.join)(primaryRepoPath, "docs", "rnd");
+        let findingsUpserted = 0;
+        let tasksUpserted = 0;
+        // ---- Sync backlog findings ----
+        const backlogDir = (0, path_1.join)(rndRoot, "backlog");
+        const backlogFiles = await this.helpers.safeReadDir(backlogDir);
+        for (const file of backlogFiles) {
+            if (!file.endsWith(".md"))
+                continue;
+            try {
+                const content = await (0, promises_1.readFile)((0, path_1.join)(backlogDir, file), "utf-8");
+                const meta = this.helpers.parseFrontmatter(content);
+                if (!meta.id)
+                    continue;
+                await this.prisma.finding.upsert({
+                    where: { projectId_externalId: { projectId, externalId: meta.id } },
+                    create: {
+                        projectId,
+                        externalId: meta.id,
+                        title: meta.title || file.replace(/\.md$/, ""),
+                        description: this.helpers.extractBody(content),
+                        severity: this.helpers.toFindingSeverity(meta.severity),
+                        category: this.helpers.toFindingCategory(meta.category),
+                        status: this.helpers.toFindingStatus(meta.status),
+                        source: "pipeline-sync",
+                    },
+                    update: {
+                        title: meta.title || undefined,
+                        description: this.helpers.extractBody(content) || undefined,
+                        severity: this.helpers.toFindingSeverity(meta.severity),
+                        category: this.helpers.toFindingCategory(meta.category),
+                        status: this.helpers.toFindingStatus(meta.status),
+                    },
+                });
+                findingsUpserted++;
+            }
+            catch (error) {
+                this.logger.warn(`Failed to sync finding from ${file}: ${error}`);
+            }
+        }
+        // ---- Sync tasks (active + completed) ----
+        for (const subdir of ["tasks", "completed"]) {
+            const tasksDir = (0, path_1.join)(rndRoot, subdir);
+            const taskFiles = await this.helpers.safeReadDir(tasksDir);
+            for (const file of taskFiles) {
+                if (!file.endsWith(".md"))
+                    continue;
+                try {
+                    const content = await (0, promises_1.readFile)((0, path_1.join)(tasksDir, file), "utf-8");
+                    const meta = this.helpers.parseFrontmatter(content);
+                    if (!meta.id)
+                        continue;
+                    await this.prisma.task.upsert({
+                        where: { projectId_externalId: { projectId, externalId: meta.id } },
+                        create: {
+                            projectId,
+                            externalId: meta.id,
+                            title: meta.title || file.replace(/\.md$/, ""),
+                            objective: this.helpers.extractBody(content),
+                            priority: this.helpers.toTaskPriority(meta.priority),
+                            status: subdir === "completed" ? "COMPLETED" : this.helpers.toTaskStatus(meta.status),
+                            effort: meta.effort || null,
+                        },
+                        update: {
+                            title: meta.title || undefined,
+                            objective: this.helpers.extractBody(content) || undefined,
+                            priority: this.helpers.toTaskPriority(meta.priority),
+                            status: subdir === "completed" ? "COMPLETED" : this.helpers.toTaskStatus(meta.status),
+                            effort: meta.effort || undefined,
+                        },
+                    });
+                    tasksUpserted++;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to sync task from ${subdir}/${file}: ${error}`);
+                }
+            }
+        }
+        return { findingsUpserted, tasksUpserted };
+    }
+    // ------------------------------------------------------------------ //
+    //  Session detail endpoints                                           //
+    // ------------------------------------------------------------------ //
+    async getSession(sessionId) {
+        const session = await this.prisma.session.findUnique({
+            where: { id: sessionId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException("Session not found");
+        return { data: session };
+    }
+    async getSessionDiff(sessionId) {
+        const session = await this.prisma.session.findUnique({
+            where: { id: sessionId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException("Session not found");
+        const metadata = session.metadata;
+        return {
+            diff: metadata?.diff ?? null,
+            diffStat: metadata?.diffStat ?? null,
+        };
+    }
+    async getSessionSummary(sessionId) {
+        const session = await this.prisma.session.findUnique({
+            where: { id: sessionId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException("Session not found");
+        const metadata = session.metadata;
+        return metadata?.summary ?? null;
+    }
+    // ------------------------------------------------------------------ //
+    //  Agent state                                                        //
+    // ------------------------------------------------------------------ //
+    /** Emit current agent slot state to all SSE listeners for a project. */
+    emitAgentState(projectId) {
+        this.helpers.emitAgentState(projectId);
+    }
+    /** Get current agent state from DB — persistent, accurate across refreshes/devices. */
+    async getAgentStateFromDb() {
+        const inProgressTasks = await this.prisma.task.findMany({
+            where: { status: "IN_PROGRESS" },
+            orderBy: { updatedAt: "asc" },
+            take: 2,
+        });
+        const planningFindings = await this.prisma.finding.findMany({
+            where: { status: "PLANNING" },
+            take: 1,
+        });
+        const reviewSession = await this.prisma.session.findFirst({
+            where: { status: "ACTIVE", phase: "REVIEW" },
+        });
+        return {
+            worker1: inProgressTasks[0] ? { taskTitle: inProgressTasks[0].title, status: "building" } : null,
+            worker2: inProgressTasks[1] ? { taskTitle: inProgressTasks[1].title, status: "building" } : null,
+            slot3: planningFindings.length > 0
+                ? { role: "Tech Lead", taskTitle: `Planning: ${planningFindings[0].title}`, status: "planning" }
+                : reviewSession
+                    ? { role: "CTO", taskTitle: "Reviewing codebase", status: "reviewing" }
+                    : null,
+        };
+    }
+    // ================================================================== //
+    //  Private helpers                                                    //
+    // ================================================================== //
+    /**
+     * Generate (or retrieve cached) a lightweight project summary from repo
+     * structure and dependencies.
+     */
+    async getOrCreateProjectContext(projectId, repos) {
+        const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+        const settings = project?.settings || {};
+        if (settings.context && settings.contextGeneratedAt) {
+            const generatedAt = new Date(settings.contextGeneratedAt).getTime();
+            const age = Date.now() - generatedAt;
+            if (age < CONTEXT_MAX_AGE_MS) {
+                return settings.context;
+            }
+            this.logger.log(`Project context is stale (${Math.round(age / 60_000)}m old) — regenerating`);
+        }
+        let context = "Project repositories:\n";
+        for (const repo of repos) {
+            try {
+                const packageJson = (0, child_process_1.execSync)("cat package.json 2>/dev/null || echo '{}'", {
+                    cwd: repo.repoPath,
+                    encoding: "utf-8",
+                });
+                const parsed = JSON.parse(packageJson);
+                context += `\n${repo.name} (${repo.repoPath}):\n`;
+                context += `  Stack: ${Object.keys(parsed.dependencies || {}).slice(0, 10).join(", ")}\n`;
+                const structure = (0, child_process_1.execSync)("find . -name '*.ts' -o -name '*.tsx' | head -20", {
+                    cwd: repo.repoPath,
+                    encoding: "utf-8",
+                });
+                context += `  Key files: ${structure.trim()}\n`;
+            }
+            catch {
+                /* ignore repos without package.json */
+            }
+        }
+        await this.prisma.project.update({
+            where: { id: projectId },
+            data: {
+                settings: {
+                    ...(project?.settings || {}),
+                    context,
+                    contextGeneratedAt: new Date().toISOString(),
+                },
+            },
+        });
+        return context;
+    }
+};
+exports.PipelineService = PipelineService;
+exports.PipelineService = PipelineService = PipelineService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_2.Inject)("PIPELINE_DATA")),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService,
+        activity_log_service_1.ActivityLogService,
+        event_bus_service_1.EventBusService, Object, pipeline_queue_service_1.PipelineQueueService,
+        pipeline_helpers_service_1.PipelineHelpersService,
+        pipeline_cto_service_1.PipelineCtoService,
+        pipeline_techlead_service_1.PipelineTechLeadService,
+        pipeline_worker_service_1.PipelineWorkerService,
+        worker_dispatch_service_1.WorkerDispatchService])
+], PipelineService);