fission-worker 0.2.1 → 0.3.0

package/runner/modules/pipeline/pipeline-orchestrator.js

@@ -0,0 +1,399 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipelineLoop = runPipelineLoop;
+const common_1 = require("@nestjs/common");
+const logger = new common_1.Logger("PipelineOrchestrator");
+/**
+ * Core pipeline orchestration loop — portable across monolith and worker containers.
+ * The caller provides all context (repos, project context, data source).
+ * This function runs the checkAndSpawn loop, captures diffs, and generates summaries.
+ */
+async function runPipelineLoop(ctx) {
+    const { data, helpers, cto, techLead, worker, sessionId, projectId, repoPath, repoPaths, repoList, projectContext, userId, stopSignal, } = ctx;
+    // Capture git HEAD for each repo before any work starts (for diff)
+    const preWorkHeads = {};
+    const repoDirs = repoList.map((r) => r.repoPath);
+    for (const dir of repoDirs) {
+        try {
+            preWorkHeads[dir] = helpers.gitRevParse(dir);
+        }
+        catch {
+            // not a git repo — ignore
+        }
+    }
+    // Clear stale state from previous runs
+    helpers.workerTasks.clear();
+    helpers.slot3Info = null;
+    worker.clearSessions();
+    const MAX_WORKERS = 2;
+    const MAX_ITERATIONS = 20;
+    let iteration = 0;
+    let activeWorkers = 0;
+    let techLeadActive = false;
+    let ctoActive = false;
+    // Track running promises
+    let runningTasks = [];
+    const isStopped = () => stopSignal?.stopped === true;
+    const checkAndSpawn = async () => {
+        if (isStopped())
+            return;
+        // ============================================================ //
+        //  Query all bucket states                                      //
+        // ============================================================ //
+        const qaQueue = await data.findTasks(projectId, {
+            status: "IN_REVIEW",
+            orderBy: [{ priority: "asc" }, { createdAt: "asc" }],
+        });
+        const devQueue = await data.findTasks(projectId, {
+            status: "READY_TO_START",
+            retryCountLt: 3,
+            orderBy: [{ priority: "asc" }, { createdAt: "asc" }],
+        });
+        const failedTasks = await data.findTasks(projectId, {
+            status: "FAILED",
+            include: { finding: { select: { id: true } } },
+        });
+        const plannedQueue = await data.findTasks(projectId, {
+            status: "PLANNED",
+            orderBy: [{ priority: "asc" }, { createdAt: "asc" }],
+        });
+        const planningFindings = await data.findFindings(projectId, {
+            status: "PLANNING",
+        });
+        const backlogFindings = await data.findFindings(projectId, {
+            status: ["NEW", "TRIAGED"],
+        });
+        const userDirections = await data.findFindings(projectId, {
+            source: "user-direction",
+            status: ["NEW", "TRIAGED"],
+        });
+        // ============================================================ //
+        //  Emit work state for monitoring                               //
+        // ============================================================ //
+        data.emit(projectId, "work_state", {
+            qaQueue: qaQueue.length,
+            devQueue: devQueue.length,
+            failedTasks: failedTasks.length,
+            plannedTasks: plannedQueue.length,
+            backlogFindings: backlogFindings.length,
+            planningFindings: planningFindings.length,
+            userDirections: userDirections.length,
+            iteration,
+            activeWorkers,
+            techLeadActive,
+            ctoActive,
+            agents: {
+                worker1: helpers.workerTasks.has(0) ? { taskTitle: helpers.workerTasks.get(0), status: "building" } : null,
+                worker2: helpers.workerTasks.has(1) ? { taskTitle: helpers.workerTasks.get(1), status: "building" } : null,
+                slot3: helpers.slot3Info ? { role: helpers.slot3Info.role, taskTitle: helpers.slot3Info.task, status: "working" } : null,
+            },
+        });
+        // ============================================================ //
+        //  Worker bucket 3: Auto-replan FAILED tasks (no slot needed)   //
+        // ============================================================ //
+        if (qaQueue.length === 0 && devQueue.length === 0 && failedTasks.length > 0) {
+            for (const task of failedTasks) {
+                await worker.replanFailedTask({
+                    id: task.id,
+                    title: task.title,
+                    objective: task.objective,
+                    projectId: task.projectId,
+                    findingId: task.findingId,
+                });
+            }
+        }
+        // ============================================================ //
+        //  Worker slots (0-1): Priority queue                           //
+        // ============================================================ //
+        const workQueue = [
+            ...qaQueue.map((t) => ({ task: t, action: "qa" })),
+            ...devQueue.map((t) => ({ task: t, action: "build" })),
+            ...plannedQueue.map((t) => ({ task: t, action: "build" })),
+        ];
+        const maxWorkersNow = Math.min(MAX_WORKERS, 3 - (techLeadActive || ctoActive ? 1 : 0));
+        let workerSlot = 0;
+        while (helpers.workerTasks.has(workerSlot) && workerSlot < MAX_WORKERS)
+            workerSlot++;
+        while (activeWorkers < maxWorkersNow && workQueue.length > 0) {
+            const { task, action } = workQueue.shift();
+            const slot = workerSlot;
+            workerSlot++;
+            while (helpers.workerTasks.has(workerSlot) && workerSlot < MAX_WORKERS)
+                workerSlot++;
+            activeWorkers++;
+            if (action === "qa") {
+                logger.log(`[${sessionId}] Spawning QA for: ${task.title} (slot: ${slot})`);
+                const qaPromise = (async () => {
+                    try {
+                        await worker.runQaAgent(task, projectId, repoPath, slot);
+                    }
+                    finally {
+                        activeWorkers--;
+                    }
+                })();
+                runningTasks.push(qaPromise);
+            }
+            else {
+                logger.log(`[${sessionId}] Spawning worker for: ${task.title} (slot: ${slot}, workers: ${activeWorkers})`);
+                const buildPromise = (async () => {
+                    try {
+                        await worker.runBuildAgent(task, projectId, repoPaths, repoPath, sessionId, projectContext, slot);
+                    }
+                    finally {
+                        activeWorkers--;
+                    }
+                })();
+                runningTasks.push(buildPromise);
+            }
+        }
+        // ============================================================ //
+        //  Slot 3: Tech Lead / CTO priority queue                       //
+        // ============================================================ //
+        if (!techLeadActive && !ctoActive) {
+            const tlHasWork = planningFindings.length > 0 || backlogFindings.length > 0;
+            if (tlHasWork && (activeWorkers + 1) <= 3) {
+                techLeadActive = true;
+                logger.log(`[${sessionId}] Spawning tech lead (planning: ${planningFindings.length}, backlog: ${backlogFindings.length})`);
+                const tlPromise = (async () => {
+                    try {
+                        await techLead.runTechLeadAgent(projectId, repoPath, sessionId, projectContext, userId);
+                    }
+                    finally {
+                        techLeadActive = false;
+                    }
+                })();
+                runningTasks.push(tlPromise);
+            }
+            else if (!tlHasWork && activeWorkers === 0) {
+                ctoActive = true;
+                logger.log(`[${sessionId}] Spawning CTO (all buckets empty)`);
+                const ctoPromise = (async () => {
+                    try {
+                        await cto.runCtoAgent(projectId, repoPath, sessionId, projectContext, userId, repoPaths, repoList, userDirections);
+                    }
+                    finally {
+                        ctoActive = false;
+                    }
+                })();
+                runningTasks.push(ctoPromise);
+            }
+        }
+    };
+    try {
+        // Main loop
+        while (iteration < MAX_ITERATIONS) {
+            if (isStopped())
+                break;
+            iteration++;
+            await checkAndSpawn();
+            // If nothing is running and nothing to spawn, check one more time then exit
+            if (runningTasks.length === 0 && activeWorkers === 0 && !techLeadActive && !ctoActive) {
+                const anyWork = await data.findFirstTask(projectId, {
+                    status: ["READY_TO_START", "PLANNED", "IN_PROGRESS", "IN_REVIEW"],
+                });
+                const anyFailed = await data.findFirstTask(projectId, { status: "FAILED" });
+                const anyPlanning = await data.findFirstFinding(projectId, { status: "PLANNING" });
+                const anyBacklog = await data.findFirstFinding(projectId, { status: ["NEW", "TRIAGED"] });
+                if (!anyWork && !anyFailed && !anyBacklog && !anyPlanning)
+                    break;
+            }
+            // Wait for at least one task to complete before re-checking
+            if (runningTasks.length > 0) {
+                const settledFlags = runningTasks.map(() => false);
+                runningTasks.forEach((p, i) => {
+                    p.then(() => { settledFlags[i] = true; }).catch(() => { settledFlags[i] = true; });
+                });
+                await Promise.race(runningTasks.map((p) => p.catch(() => { })));
+                await new Promise((r) => setTimeout(r, 1000));
+                runningTasks = runningTasks.filter((_, i) => !settledFlags[i]);
+            }
+            else {
+                await new Promise((r) => setTimeout(r, 2000));
+            }
+        }
+        // Wait for ALL remaining tasks to finish before declaring complete
+        if (runningTasks.length > 0) {
+            logger.log(`[${sessionId}] Waiting for ${runningTasks.length} remaining agent(s) to finish...`);
+            await Promise.all(runningTasks.map((p) => p.catch(() => { })));
+        }
+        // Capture git diffs for the session
+        const diffs = {};
+        for (const dir of repoDirs) {
+            const oldHead = preWorkHeads[dir];
+            if (!oldHead)
+                continue;
+            try {
+                const newHead = helpers.gitRevParse(dir);
+                if (oldHead !== newHead) {
+                    diffs[dir] = {
+                        diff: helpers.gitDiff(dir, oldHead, newHead),
+                        diffStat: helpers.gitDiffStat(dir, oldHead, newHead),
+                    };
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to capture post-work diff for ${dir}: ${err}`);
+            }
+        }
+        if (Object.keys(diffs).length > 0) {
+            const allDiffs = Object.values(diffs).map((d) => d.diff).join("\n");
+            const allDiffStats = Object.values(diffs).map((d) => d.diffStat).join("\n");
+            await data.updateSession(sessionId, {
+                metadata: { diff: allDiffs.slice(0, 50_000), diffStat: allDiffStats },
+            });
+        }
+    }
+    catch (err) {
+        logger.error(`Pipeline ${sessionId} failed: ${err}`);
+        await data.log("PIPELINE_ERROR", "Session", sessionId, userId, { error: String(err) });
+    }
+    finally {
+        helpers.workerTasks.clear();
+        helpers.slot3Info = null;
+        worker.clearSessions();
+        await data.updateSession(sessionId, { phase: "SHIP" });
+        data.emit(projectId, "phase_changed", { sessionId, phase: "SHIP" });
+        data.emit(projectId, "pipeline_complete", { sessionId });
+        // Generate and store run summary
+        const summary = await generateRunSummary(ctx, repoDirs, preWorkHeads).catch((err) => {
+            logger.warn(`Failed to generate run summary: ${err}`);
+            return null;
+        });
+        if (summary) {
+            const existingSession = await data.findSession(sessionId);
+            const existingMeta = existingSession?.metadata || {};
+            await data.updateSession(sessionId, {
+                metadata: { ...existingMeta, summary },
+            }).catch((err) => logger.warn(`Failed to store run summary: ${err}`));
+            data.emit(projectId, "pipeline_summary", { sessionId, summary });
+            await data.log("PIPELINE_SUMMARY", "Session", sessionId, userId, {
+                duration: summary.duration,
+                tasksCompleted: summary.tasksCompleted.length,
+                tasksFailed: summary.tasksFailed.length,
+                findingsCreated: summary.findingsCreated,
+                filesChanged: summary.filesChanged.length,
+                commits: summary.commitMessages.length,
+            });
+        }
+        await data.updateSession(sessionId, { status: "TERMINATED", endedAt: new Date() });
+        await data.log("PIPELINE_FINISH", "Session", sessionId, userId);
+        logger.log(`[${sessionId}] All agents finished`);
+    }
+}
+/**
+ * Generate a structured summary of a pipeline run.
+ * Portable — uses only PipelineDataSource + git helpers.
+ */
+async function generateRunSummary(ctx, repoDirs, preWorkHeads) {
+    const { data, helpers, sessionId, projectId } = ctx;
+    const { execSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
+    const session = await data.findSession(sessionId);
+    const startedAt = session?.startedAt ?? new Date();
+    const endedAt = new Date();
+    const durationMs = endedAt.getTime() - new Date(startedAt).getTime();
+    const totalSeconds = Math.floor(durationMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const duration = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    // Use data source to get completed/failed tasks (with time filter approximation)
+    const completedTasks = await data.findTasks(projectId, { status: "COMPLETED" });
+    const failedTasks = await data.findTasks(projectId, { status: "FAILED" });
+    const tasksCompleted = completedTasks
+        .filter((t) => new Date(t.updatedAt) >= new Date(startedAt))
+        .map((t) => ({
+        id: t.id,
+        title: t.title,
+        summary: t.metadata?.summary,
+    }));
+    const tasksFailed = failedTasks
+        .filter((t) => new Date(t.updatedAt) >= new Date(startedAt))
+        .map((t) => ({
+        id: t.id,
+        title: t.title,
+        error: t.metadata?.error,
+    }));
+    // Count findings created during this session
+    const allFindings = await data.findFindings(projectId, {});
+    const findingsCreated = allFindings.filter((f) => new Date(f.createdAt) >= new Date(startedAt)).length;
+    const filesChanged = [];
+    const commitMessages = [];
+    for (const dir of repoDirs) {
+        const oldHead = preWorkHeads[dir];
+        if (!oldHead)
+            continue;
+        try {
+            const newHead = helpers.gitRevParse(dir);
+            if (oldHead === newHead)
+                continue;
+            const diffStat = helpers.gitDiffStat(dir, oldHead, newHead);
+            const fileLines = diffStat.split("\n").filter((l) => l.includes("|"));
+            for (const line of fileLines) {
+                const fileName = line.split("|")[0].trim();
+                if (fileName)
+                    filesChanged.push(fileName);
+            }
+            if (helpers.isValidSha(oldHead) && helpers.isValidSha(newHead)) {
+                try {
+                    helpers.validateRepoPath(dir);
+                    const logOutput = execSync(`git log --oneline ${oldHead}..${newHead}`, {
+                        cwd: dir,
+                        encoding: "utf-8",
+                    });
+                    for (const line of logOutput.trim().split("\n")) {
+                        if (line.trim())
+                            commitMessages.push(line.trim());
+                    }
+                }
+                catch {
+                    // ignore — no commits
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {
+        sessionId,
+        projectName: session?.project?.name ?? "Unknown",
+        duration,
+        tasksCompleted,
+        tasksFailed,
+        findingsCreated,
+        filesChanged,
+        commitMessages,
+    };
+}

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

@@ -0,0 +1,121 @@
+"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 PipelineQueueService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineQueueService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Global singleton queue that ensures only one pipeline runs at a time.
+ * Other pipelines wait in FIFO order until the current one finishes.
+ */
+let PipelineQueueService = PipelineQueueService_1 = class PipelineQueueService {
+    logger = new common_1.Logger(PipelineQueueService_1.name);
+    running = null;
+    queue = [];
+    /** Callback set by PipelineService to actually start execution. */
+    startCallback = null;
+    /** Register the function that starts pipeline execution. */
+    onStartNext(cb) {
+        this.startCallback = cb;
+    }
+    /** True if a pipeline is currently executing. */
+    isRunning() {
+        return this.running !== null;
+    }
+    /**
+     * Returns the queue position for a session.
+     * -1 = not found, 0 = currently running, 1+ = waiting in queue.
+     */
+    getQueuePosition(sessionId) {
+        if (this.running?.sessionId === sessionId)
+            return 0;
+        const idx = this.queue.findIndex((e) => e.sessionId === sessionId);
+        return idx === -1 ? -1 : idx + 1;
+    }
+    /** Number of entries waiting (not including the currently running one). */
+    getQueueLength() {
+        return this.queue.length;
+    }
+    /** Full status snapshot for the REST endpoint. */
+    getStatus() {
+        return {
+            running: this.running
+                ? { sessionId: this.running.sessionId, projectId: this.running.projectId }
+                : null,
+            queue: this.queue.map((e) => ({
+                sessionId: e.sessionId,
+                projectId: e.projectId,
+            })),
+        };
+    }
+    /**
+     * Add a pipeline to the queue.
+     * If the slot is empty, starts it immediately (position 0).
+     * Otherwise queues it (position 1+).
+     */
+    enqueue(entry) {
+        if (!this.running) {
+            this.running = entry;
+            this.logger.log(`Pipeline ${entry.sessionId} starts immediately (no queue)`);
+            this.startCallback?.(entry);
+            return { position: 0 };
+        }
+        this.queue.push(entry);
+        const position = this.queue.length;
+        this.logger.log(`Pipeline ${entry.sessionId} queued at position ${position}`);
+        return { position };
+    }
+    /**
+     * Called when the current pipeline finishes (success or error).
+     * Promotes the next entry in the queue, if any.
+     */
+    dequeue() {
+        const finished = this.running;
+        this.running = null;
+        if (finished) {
+            this.logger.log(`Pipeline ${finished.sessionId} finished, slot freed`);
+        }
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            this.running = next;
+            this.logger.log(`Pipeline ${next.sessionId} promoted from queue, starting`);
+            this.startCallback?.(next);
+        }
+    }
+    /**
+     * Cancel a session — remove from queue or mark running slot as free.
+     * Returns true if the session was found and removed.
+     */
+    cancel(sessionId) {
+        // If it's the running entry, clear the slot (caller handles killing the process)
+        if (this.running?.sessionId === sessionId) {
+            this.logger.log(`Cancelling running pipeline ${sessionId}`);
+            this.running = null;
+            // Start the next queued entry
+            if (this.queue.length > 0) {
+                const next = this.queue.shift();
+                this.running = next;
+                this.logger.log(`Pipeline ${next.sessionId} promoted from queue after cancel`);
+                this.startCallback?.(next);
+            }
+            return true;
+        }
+        // If it's in the queue, remove it
+        const idx = this.queue.findIndex((e) => e.sessionId === sessionId);
+        if (idx !== -1) {
+            this.queue.splice(idx, 1);
+            this.logger.log(`Removed queued pipeline ${sessionId} from position ${idx + 1}`);
+            return true;
+        }
+        return false;
+    }
+};
+exports.PipelineQueueService = PipelineQueueService;
+exports.PipelineQueueService = PipelineQueueService = PipelineQueueService_1 = __decorate([
+    (0, common_1.Injectable)()
+], PipelineQueueService);

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

@@ -0,0 +1,127 @@
+"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 PipelineTechLeadService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineTechLeadService = void 0;
+const common_1 = require("@nestjs/common");
+const common_2 = require("@nestjs/common");
+const pipeline_helpers_service_1 = require("./pipeline-helpers.service");
+let PipelineTechLeadService = PipelineTechLeadService_1 = class PipelineTechLeadService {
+    data;
+    helpers;
+    logger = new common_1.Logger(PipelineTechLeadService_1.name);
+    constructor(data, helpers) {
+        this.data = data;
+        this.helpers = helpers;
+    }
+    async runTechLeadAgent(projectId, repoPath, sessionId, projectContext, userId) {
+        this.data.emit(projectId, "phase_changed", { sessionId, phase: "PLAN", reason: "Tech Lead planning" });
+        this.logger.log(`[${sessionId}] Tech Lead: planning backlog findings`);
+        this.helpers.slot3Info = { role: "Tech Lead", task: "Planning backlog" };
+        this.helpers.emitAgentState(projectId);
+        // Priority 1: Resume interrupted PLANNING findings from previous runs
+        const planningFindings = await this.data.findFindings(projectId, {
+            status: "PLANNING",
+            orderBy: [{ severity: "asc" }, { createdAt: "asc" }],
+            take: 2,
+        });
+        // Priority 2: Pick up NEW/TRIAGED findings from backlog
+        const remainingSlots = 2 - planningFindings.length;
+        const newFindings = remainingSlots > 0
+            ? await this.data.findFindings(projectId, {
+                status: ["NEW", "TRIAGED"],
+                orderBy: [{ severity: "asc" }, { createdAt: "asc" }],
+                take: remainingSlots,
+            })
+            : [];
+        const findings = [...planningFindings, ...newFindings];
+        if (findings.length === 0)
+            return;
+        // Move NEW/TRIAGED findings to PLANNING status (already-PLANNING ones stay)
+        const toMarkPlanning = newFindings.filter((f) => f.status !== "PLANNING").map((f) => f.id);
+        if (toMarkPlanning.length > 0) {
+            await this.data.updateManyFindings(toMarkPlanning, { status: "PLANNING" });
+        }
+        const findingsSummary = findings.map((f) => ({
+            id: f.id,
+            title: f.title,
+            description: f.description,
+            severity: f.severity,
+            category: f.category,
+        }));
+        this.helpers.slot3Info = { role: "Tech Lead", task: `Planning: ${findings[0].title}` };
+        this.helpers.emitAgentState(projectId);
+        const planPrompt = (projectContext ? `Project context:\n${projectContext}\n\n` : "") +
+            `You are a Tech Lead. Analyze these findings and break each into concrete implementation tasks.\n` +
+            `Findings:\n${JSON.stringify(findingsSummary)}\n\n` +
+            `For EACH finding, create 1-3 specific implementation tasks. Each task should be:\n` +
+            `- Small enough for one developer to complete\n` +
+            `- Specific about what files/modules to change\n` +
+            `- Clear about the expected outcome\n\n` +
+            `Return JSON array: [{title, objective (1-2 sentences), priority (CRITICAL/HIGH/MEDIUM/LOW), effort (small/medium/large), findingId}]\n` +
+            `ONLY valid JSON.`;
+        const planResult = await this.helpers.spawnClaude(planPrompt, repoPath, "claude-sonnet-4-6", undefined, { projectId, phase: "PLAN" });
+        const tasks = this.helpers.parseClaudeJson(planResult.stdout);
+        let tasksCreated = 0;
+        if (tasks && Array.isArray(tasks)) {
+            for (const t of tasks) {
+                try {
+                    let validFindingId = null;
+                    if (t.findingId) {
+                        const exists = await this.data.findFindingById(t.findingId);
+                        if (exists)
+                            validFindingId = t.findingId;
+                    }
+                    const created = await this.data.createTask({
+                        projectId,
+                        findingId: validFindingId,
+                        title: t.title,
+                        objective: t.objective || null,
+                        priority: this.helpers.toTaskPriority(t.priority),
+                        status: "READY_TO_START",
+                        effort: t.effort || null,
+                    });
+                    // Add tech-lead comment documenting creation context
+                    const linkedFinding = findingsSummary.find((f) => f.id === validFindingId);
+                    await this.data.createTaskComment({
+                        taskId: created.id,
+                        author: "tech-lead",
+                        content: `Created from finding: "${linkedFinding?.title || "unknown"}". ${t.objective || ""}. Effort: ${t.effort || "unknown"}.`,
+                    });
+                    this.data.emit(projectId, "task_created", { id: created.id, title: created.title, priority: created.priority, status: created.status });
+                    if (validFindingId) {
+                        await this.data.updateFinding(validFindingId, { status: "TASKED" });
+                    }
+                    tasksCreated++;
+                }
+                catch (err) {
+                    this.logger.warn(`Failed to create task: ${err}`);
+                }
+            }
+        }
+        await this.data.log("WORK_COMPLETED", "Session", sessionId, userId, {
+            type: "PLAN",
+            tasksCreated,
+        });
+        // Clear slot 3 tracking
+        this.helpers.slot3Info = null;
+    }
+};
+exports.PipelineTechLeadService = PipelineTechLeadService;
+exports.PipelineTechLeadService = PipelineTechLeadService = PipelineTechLeadService_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])
+], PipelineTechLeadService);