cortex-agents 2.3.0 → 3.4.0

package/dist/tools/environment.js

@@ -0,0 +1,93 @@
+/**
+ * Environment Detection Tool
+ *
+ * Provides agents with information about the current development environment
+ * (IDE, terminal, editor) to offer contextually appropriate worktree launch options.
+ *
+ * Uses two detection systems:
+ *   - IDE detection (ide.ts) — for "Open in IDE" options
+ *   - Terminal detection (terminal.ts) — for "Open in terminal tab" options
+ *
+ * The terminal detection uses a multi-strategy chain:
+ *   1. Environment variables (fast, synchronous)
+ *   2. Process-tree walk (finds terminal in parent processes)
+ *   3. Frontmost app detection (macOS only)
+ *   4. User preference (.cortex/config.json)
+ */
+import { tool } from "@opencode-ai/plugin";
+import { detectIDEWithCLICheck, formatEnvironmentReport, generateEnvironmentRecommendations } from "../utils/ide.js";
+import { detectDriver, detectTerminalDriver } from "../utils/terminal.js";
+export const detectEnvironment = tool({
+    description: "Detect the current development environment (IDE, terminal, editor) " +
+        "to offer contextually appropriate worktree launch options. " +
+        "Returns environment info and recommended launch options.",
+    args: {},
+    async execute(args, context) {
+        // Use async detection that verifies CLI availability in PATH
+        const ide = await detectIDEWithCLICheck();
+        const ideDriver = detectDriver();
+        // Multi-strategy terminal detection (the one used for "Open in terminal tab")
+        const terminalDetection = await detectTerminalDriver(context.worktree);
+        // Format the report (now includes CLI availability status)
+        const report = formatEnvironmentReport(ide, terminalDetection.driver.name);
+        // Add CLI status section
+        const additionalInfo = [];
+        additionalInfo.push(``, `### CLI Status`, ``);
+        additionalInfo.push(`- IDE: ${ide.name}`);
+        additionalInfo.push(`- IDE Driver: ${ideDriver.name}`);
+        additionalInfo.push(`- Terminal Emulator: **${terminalDetection.driver.name}**`);
+        additionalInfo.push(`- Platform: ${process.platform}`);
+        if (ide.cliBinary) {
+            if (ide.cliAvailable) {
+                additionalInfo.push(`- CLI: \`${ide.cliBinary}\` available in PATH`);
+            }
+            else {
+                additionalInfo.push(`- CLI: \`${ide.cliBinary}\` **NOT found** in PATH`);
+                if (ide.cliInstallHint) {
+                    additionalInfo.push(`- Fix: ${ide.cliInstallHint}`);
+                }
+            }
+        }
+        // Terminal detection details
+        additionalInfo.push(``, `### Terminal Detection`, ``);
+        additionalInfo.push(`- Strategy: **${terminalDetection.strategy}**`);
+        if (terminalDetection.detail) {
+            additionalInfo.push(`- Detail: ${terminalDetection.detail}`);
+        }
+        additionalInfo.push(`- Driver: ${terminalDetection.driver.name}`);
+        additionalInfo.push(``);
+        additionalInfo.push(`When "Open in terminal tab" is selected, a new tab will open in **${terminalDetection.driver.name}**.`);
+        return report + additionalInfo.join("\n");
+    },
+});
+/**
+ * Quick environment check tool for agents.
+ * Returns a simplified response for quick decision-making.
+ */
+export const getEnvironmentInfo = tool({
+    description: "Get quick environment info for deciding worktree launch options. " +
+        "Returns IDE type, terminal name, and whether to offer IDE-specific options.",
+    args: {},
+    async execute(args, context) {
+        const ide = await detectIDEWithCLICheck();
+        const terminalDetection = await detectTerminalDriver(context.worktree);
+        return JSON.stringify({
+            ide: {
+                type: ide.type,
+                name: ide.name,
+                hasIntegratedTerminal: ide.hasIntegratedTerminal,
+                canOpenInWindow: ide.canOpenInWindow,
+                cliAvailable: ide.cliAvailable,
+                cliBinary: ide.cliBinary,
+                cliInstallHint: ide.cliInstallHint,
+            },
+            terminal: {
+                name: terminalDetection.driver.name,
+                detectionStrategy: terminalDetection.strategy,
+                detectionDetail: terminalDetection.detail,
+            },
+            platform: process.platform,
+            recommendations: generateEnvironmentRecommendations(ide),
+        }, null, 2);
+    },
+});

package/dist/tools/github.d.ts

@@ -0,0 +1,42 @@
+export declare const status: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const issues: {
+    description: string;
+    args: {
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
+            closed: "closed";
+            open: "open";
+            all: "all";
+        }>>;
+        labels: import("zod").ZodOptional<import("zod").ZodString>;
+        milestone: import("zod").ZodOptional<import("zod").ZodString>;
+        assignee: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        detailed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        state?: "closed" | "open" | "all" | undefined;
+        labels?: string | undefined;
+        milestone?: string | undefined;
+        assignee?: string | undefined;
+        limit?: number | undefined;
+        detailed?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const projects: {
+    description: string;
+    args: {
+        projectNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        projectNumber?: number | undefined;
+        status?: string | undefined;
+        limit?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=github.d.ts.map

package/dist/tools/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../src/tools/github.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,MAAM;;;;CAgDjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;CAsEjB,CAAC;AAIH,eAAO,MAAM,QAAQ;;;;;;;;;;;;CA0EnB,CAAC"}

package/dist/tools/github.js

@@ -0,0 +1,200 @@
+import { tool } from "@opencode-ai/plugin";
+import { checkGhAvailability, fetchIssues, fetchProjects, fetchProjectItems, formatIssueList, formatIssueForPlan, formatProjectItemList, } from "../utils/github.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Validate GitHub CLI availability and return status.
+ * Returns a formatted error string if not available, or the status object.
+ */
+async function requireGh(cwd) {
+    const status = await checkGhAvailability(cwd);
+    if (!status.installed) {
+        return {
+            ok: false,
+            error: "✗ GitHub CLI (gh) is not installed.\n\nInstall it from https://cli.github.com/ and run `gh auth login`.",
+        };
+    }
+    if (!status.authenticated) {
+        return {
+            ok: false,
+            error: "✗ GitHub CLI is not authenticated.\n\nRun `gh auth login` to authenticate.",
+        };
+    }
+    return { ok: true, status };
+}
+// ─── Tool: github_status ─────────────────────────────────────────────────────
+export const status = tool({
+    description: "Check GitHub CLI availability, authentication, and detect GitHub Projects for the current repository. " +
+        "Use this first to verify the repo is connected before listing issues or projects.",
+    args: {},
+    async execute(_args, context) {
+        const status = await checkGhAvailability(context.worktree);
+        const lines = [];
+        // Installation
+        lines.push(status.installed ? "✓ GitHub CLI installed" : "✗ GitHub CLI not installed");
+        if (!status.installed) {
+            lines.push("  Install from https://cli.github.com/");
+            return lines.join("\n");
+        }
+        // Authentication
+        lines.push(status.authenticated ? "✓ Authenticated" : "✗ Not authenticated");
+        if (!status.authenticated) {
+            lines.push("  Run: gh auth login");
+            return lines.join("\n");
+        }
+        // Remote
+        if (status.hasRemote && status.repoOwner && status.repoName) {
+            lines.push(`✓ Repository: ${status.repoOwner}/${status.repoName}`);
+            // Fetch projects
+            const projects = await fetchProjects(context.worktree, status.repoOwner);
+            status.projects = projects;
+            if (projects.length > 0) {
+                lines.push("");
+                lines.push(`GitHub Projects (${projects.length}):`);
+                for (const p of projects) {
+                    lines.push(`  #${p.number}: ${p.title}`);
+                }
+            }
+            else {
+                lines.push("  No GitHub Projects found for this repository owner.");
+            }
+        }
+        else {
+            lines.push("✗ No GitHub remote (origin) configured");
+            lines.push("  Add one with: git remote add origin <url>");
+        }
+        return lines.join("\n");
+    },
+});
+// ─── Tool: github_issues ─────────────────────────────────────────────────────
+export const issues = tool({
+    description: "List GitHub issues for the current repository, filterable by state, labels, milestone, and assignee. " +
+        "Returns a formatted list suitable for selecting issues to plan. " +
+        "Set `detailed` to true to get full issue descriptions for plan seeding.",
+    args: {
+        state: tool.schema
+            .enum(["open", "closed", "all"])
+            .optional()
+            .describe("Filter by issue state (default: open)"),
+        labels: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by labels (comma-separated, e.g., 'bug,priority:high')"),
+        milestone: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by milestone name"),
+        assignee: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by assignee username"),
+        limit: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum number of issues to return (default: 20, max: 100)"),
+        detailed: tool.schema
+            .boolean()
+            .optional()
+            .describe("If true, return full issue details formatted for plan seeding (default: false)"),
+    },
+    async execute(args, context) {
+        const check = await requireGh(context.worktree);
+        if (!check.ok)
+            return check.error;
+        const limit = Math.min(Math.max(args.limit ?? 20, 1), 100);
+        try {
+            const issueList = await fetchIssues(context.worktree, {
+                state: args.state ?? "open",
+                labels: args.labels,
+                milestone: args.milestone,
+                assignee: args.assignee,
+                limit,
+            });
+            if (issueList.length === 0) {
+                const filters = [];
+                if (args.state)
+                    filters.push(`state: ${args.state}`);
+                if (args.labels)
+                    filters.push(`labels: ${args.labels}`);
+                if (args.milestone)
+                    filters.push(`milestone: ${args.milestone}`);
+                if (args.assignee)
+                    filters.push(`assignee: ${args.assignee}`);
+                const filterStr = filters.length > 0 ? ` (filters: ${filters.join(", ")})` : "";
+                return `No issues found${filterStr}.`;
+            }
+            const header = `Found ${issueList.length} issue(s):\n\n`;
+            if (args.detailed) {
+                // Full detail mode for plan seeding
+                const formatted = issueList.map((issue) => formatIssueForPlan(issue)).join("\n\n---\n\n");
+                return header + formatted;
+            }
+            // Compact list mode for selection
+            return header + formatIssueList(issueList);
+        }
+        catch (error) {
+            return `✗ Error fetching issues: ${error.message || error}`;
+        }
+    },
+});
+// ─── Tool: github_projects ───────────────────────────────────────────────────
+export const projects = tool({
+    description: "List GitHub Project boards and their work items for the current repository. " +
+        "Without a projectNumber, lists all projects. " +
+        "With a projectNumber, lists items from that specific project board.",
+    args: {
+        projectNumber: tool.schema
+            .number()
+            .optional()
+            .describe("Specific project number to list items from (omit to list all projects)"),
+        status: tool.schema
+            .string()
+            .optional()
+            .describe("Filter project items by status column (e.g., 'Todo', 'In Progress')"),
+        limit: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum number of items to return (default: 30)"),
+    },
+    async execute(args, context) {
+        const check = await requireGh(context.worktree);
+        if (!check.ok)
+            return check.error;
+        const { status: ghStatus } = check;
+        if (!ghStatus.hasRemote || !ghStatus.repoOwner) {
+            return "✗ No GitHub remote (origin) configured. Cannot fetch projects.";
+        }
+        const owner = ghStatus.repoOwner;
+        try {
+            // If no project number specified, list all projects
+            if (args.projectNumber === undefined) {
+                const projectList = await fetchProjects(context.worktree, owner);
+                if (projectList.length === 0) {
+                    return `No GitHub Projects found for ${owner}.`;
+                }
+                const lines = [`GitHub Projects for ${owner} (${projectList.length}):\n`];
+                for (const p of projectList) {
+                    lines.push(`  #${p.number}: ${p.title}`);
+                }
+                lines.push("");
+                lines.push("Use github_projects with a projectNumber to list items from a specific project.");
+                return lines.join("\n");
+            }
+            // Fetch items from a specific project (cap limit for safety)
+            const limit = Math.min(Math.max(args.limit ?? 30, 1), 100);
+            const items = await fetchProjectItems(context.worktree, owner, args.projectNumber, {
+                status: args.status,
+                limit,
+            });
+            if (items.length === 0) {
+                const statusFilter = args.status ? ` with status "${args.status}"` : "";
+                return `No items found in project #${args.projectNumber}${statusFilter}.`;
+            }
+            const statusFilter = args.status ? ` (status: ${args.status})` : "";
+            const header = `Project #${args.projectNumber} — ${items.length} item(s)${statusFilter}:\n\n`;
+            return header + formatProjectItemList(items);
+        }
+        catch (error) {
+            return `✗ Error fetching projects: ${error.message || error}`;
+        }
+    },
+});

package/dist/tools/repl.d.ts

@@ -0,0 +1,50 @@
+/**
+ * REPL Loop Tools
+ *
+ * Four tools for the implement agent's iterative task-by-task development loop:
+ *   - repl_init    — Initialize a loop from a plan
+ *   - repl_status  — Get current progress and next task
+ *   - repl_report  — Report task outcome (pass/fail/skip)
+ *   - repl_summary — Generate markdown summary for PR body
+ */
+export declare const init: {
+    description: string;
+    args: {
+        planFilename: import("zod").ZodString;
+        buildCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        testCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        maxRetries: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        planFilename: string;
+        buildCommand?: string | undefined;
+        testCommand?: string | undefined;
+        maxRetries?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const status: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const report: {
+    description: string;
+    args: {
+        result: import("zod").ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+        }>;
+        detail: import("zod").ZodString;
+    };
+    execute(args: {
+        result: "pass" | "fail" | "skip";
+        detail: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const summary: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=repl.d.ts.map

package/dist/tools/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/tools/repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwBH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAqGf,CAAC;AAIH,eAAO,MAAM,MAAM;;;;CAyBjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;CAwCjB,CAAC;AA8EH,eAAO,MAAM,OAAO;;;;CAclB,CAAC"}

package/dist/tools/repl.js

@@ -0,0 +1,240 @@
+/**
+ * REPL Loop Tools
+ *
+ * Four tools for the implement agent's iterative task-by-task development loop:
+ *   - repl_init    — Initialize a loop from a plan
+ *   - repl_status  — Get current progress and next task
+ *   - repl_report  — Report task outcome (pass/fail/skip)
+ *   - repl_summary — Generate markdown summary for PR body
+ */
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+import { parseTasksFromPlan, detectCommands, readReplState, writeReplState, getNextTask, getCurrentTask, isLoopComplete, formatProgress, formatSummary, } from "../utils/repl.js";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+// ─── repl_init ───────────────────────────────────────────────────────────────
+export const init = tool({
+    description: "Initialize a REPL implementation loop from a plan. Parses plan tasks, " +
+        "auto-detects build/test commands, and creates .cortex/repl-state.json " +
+        "for tracking progress through each task iteratively.",
+    args: {
+        planFilename: tool.schema
+            .string()
+            .describe("Plan filename from .cortex/plans/ to load tasks from"),
+        buildCommand: tool.schema
+            .string()
+            .optional()
+            .describe("Override auto-detected build command (e.g., 'npm run build')"),
+        testCommand: tool.schema
+            .string()
+            .optional()
+            .describe("Override auto-detected test command (e.g., 'npm test')"),
+        maxRetries: tool.schema
+            .number()
+            .optional()
+            .describe("Max retries per failing task before escalating to user (default: 3)"),
+    },
+    async execute(args, context) {
+        const { planFilename, buildCommand, testCommand, maxRetries = 3 } = args;
+        const cwd = context.worktree;
+        // 1. Validate plan filename
+        if (!planFilename || planFilename === "." || planFilename === "..") {
+            return `\u2717 Error: Invalid plan filename.`;
+        }
+        const plansDir = path.join(cwd, CORTEX_DIR, PLANS_DIR);
+        const planPath = path.resolve(plansDir, planFilename);
+        const resolvedPlansDir = path.resolve(plansDir);
+        // Prevent path traversal — resolved path must be strictly inside plans dir
+        if (!planPath.startsWith(resolvedPlansDir + path.sep)) {
+            return `\u2717 Error: Invalid plan filename.`;
+        }
+        if (!fs.existsSync(planPath)) {
+            return `\u2717 Error: Plan not found: ${planFilename}\n\nUse plan_list to see available plans.`;
+        }
+        const planContent = fs.readFileSync(planPath, "utf-8");
+        // 2. Parse tasks from plan
+        const taskDescriptions = parseTasksFromPlan(planContent);
+        if (taskDescriptions.length === 0) {
+            return `\u2717 Error: No tasks found in plan: ${planFilename}\n\nThe plan must contain unchecked checkbox items (- [ ] ...) in a ## Tasks section.`;
+        }
+        // 3. Auto-detect commands (or use overrides)
+        const detected = await detectCommands(cwd);
+        const finalBuild = buildCommand ?? detected.buildCommand;
+        const finalTest = testCommand ?? detected.testCommand;
+        // 4. Build initial state
+        const tasks = taskDescriptions.map((desc, i) => ({
+            index: i,
+            description: desc,
+            status: "pending",
+            retries: 0,
+            iterations: [],
+        }));
+        const state = {
+            planFilename,
+            startedAt: new Date().toISOString(),
+            buildCommand: finalBuild,
+            testCommand: finalTest,
+            lintCommand: detected.lintCommand,
+            maxRetries,
+            currentTaskIndex: -1,
+            tasks,
+        };
+        // 5. Write state
+        writeReplState(cwd, state);
+        // 6. Format output
+        const cmdInfo = detected.detected
+            ? `Auto-detected (${detected.framework})`
+            : "Not detected \u2014 provide overrides if needed";
+        return `\u2713 REPL loop initialized
+
+Plan: ${planFilename}
+Tasks: ${tasks.length}
+Detection: ${cmdInfo}
+
+Build: ${finalBuild || "(none)"}
+Test:  ${finalTest || "(none)"}
+${detected.lintCommand ? `Lint:  ${detected.lintCommand}` : ""}
+Max retries: ${maxRetries}
+
+First task (#1):
+  "${tasks[0].description}"
+
+Run \`repl_status\` to begin, then implement the task and run build/tests.`;
+    },
+});
+// ─── repl_status ─────────────────────────────────────────────────────────────
+export const status = tool({
+    description: "Get the current REPL loop progress \u2014 which task is active, " +
+        "what\u2019s been completed, retry counts, and detected build/test commands. " +
+        "Call this to decide what to implement next.",
+    args: {},
+    async execute(args, context) {
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop active.\n\nRun repl_init with a plan filename to start a loop.`;
+        }
+        // Auto-advance: if no task is in_progress, promote the next pending task
+        const current = getCurrentTask(state);
+        if (!current && !isLoopComplete(state)) {
+            const next = getNextTask(state);
+            if (next) {
+                next.status = "in_progress";
+                state.currentTaskIndex = next.index;
+                writeReplState(context.worktree, state);
+            }
+        }
+        return `\u2713 REPL Loop Status\n\n${formatProgress(state)}`;
+    },
+});
+// ─── repl_report ─────────────────────────────────────────────────────────────
+export const report = tool({
+    description: "Report the outcome of the current task iteration. " +
+        "After implementing a task and running build/tests, report whether it passed, " +
+        "failed, or should be skipped. The loop will auto-advance on pass, " +
+        "retry on fail (up to max), or escalate to user when retries exhausted.",
+    args: {
+        result: tool.schema
+            .enum(["pass", "fail", "skip"])
+            .describe("Task result: 'pass' (build+tests green), 'fail' (something broke), 'skip' (defer task)"),
+        detail: tool.schema
+            .string()
+            .describe("Result details: test output summary, error message, or skip reason"),
+    },
+    async execute(args, context) {
+        const { result, detail } = args;
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop active. Run repl_init first.`;
+        }
+        // Find the current in_progress task
+        const current = getCurrentTask(state);
+        if (!current) {
+            // Try to find the task at currentTaskIndex
+            if (state.currentTaskIndex >= 0 && state.currentTaskIndex < state.tasks.length) {
+                const task = state.tasks[state.currentTaskIndex];
+                if (task.status === "pending") {
+                    task.status = "in_progress";
+                }
+                return processReport(state, task, result, detail, context.worktree);
+            }
+            return `\u2717 No task is currently in progress.\n\nRun repl_status to advance to the next task.`;
+        }
+        return processReport(state, current, result, detail, context.worktree);
+    },
+});
+/**
+ * Process a report for a task and update state.
+ */
+function processReport(state, task, result, detail, cwd) {
+    // Record iteration
+    task.iterations.push({
+        at: new Date().toISOString(),
+        result,
+        detail: detail.substring(0, 2000), // Cap detail length
+    });
+    const taskNum = task.index + 1;
+    const taskDesc = task.description;
+    let output;
+    switch (result) {
+        case "pass": {
+            task.status = "passed";
+            const attempt = task.iterations.length;
+            const suffix = attempt === 1 ? "1st" : attempt === 2 ? "2nd" : attempt === 3 ? "3rd" : `${attempt}th`;
+            output = `\u2713 Task #${taskNum} PASSED (${suffix} attempt)\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}`;
+            break;
+        }
+        case "fail": {
+            task.retries += 1;
+            const attempt = task.iterations.length;
+            if (task.retries >= state.maxRetries) {
+                // Retries exhausted
+                task.status = "failed";
+                output = `\u2717 Task #${taskNum} FAILED \u2014 retries exhausted (${attempt}/${state.maxRetries} attempts)\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}\n\n\u2192 ASK THE USER how to proceed. Suggest: fix manually, skip task, or abort loop.`;
+            }
+            else {
+                // Retries remaining — stay in_progress
+                const remaining = state.maxRetries - task.retries;
+                output = `\u26A0 Task #${taskNum} FAILED (attempt ${attempt}/${state.maxRetries})\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}\n\n\u2192 Fix the issue and run build/tests again. ${remaining} retr${remaining > 1 ? "ies" : "y"} remaining.`;
+                // Don't advance — keep task in_progress
+                writeReplState(cwd, state);
+                return output;
+            }
+            break;
+        }
+        case "skip": {
+            task.status = "skipped";
+            output = `\u2298 Task #${taskNum} SKIPPED\n  "${taskDesc}"\n  Reason: ${detail.substring(0, 200)}`;
+            break;
+        }
+    }
+    // Advance to next task
+    const next = getNextTask(state);
+    if (next) {
+        next.status = "in_progress";
+        state.currentTaskIndex = next.index;
+        output += `\n\n\u2192 Next: Task #${next.index + 1} "${next.description}"`;
+    }
+    else {
+        // All tasks done
+        state.currentTaskIndex = -1;
+        state.completedAt = new Date().toISOString();
+        output += "\n\n\u2713 All tasks complete. Run repl_summary to generate the results report, then proceed to the quality gate (Step 7).";
+    }
+    writeReplState(cwd, state);
+    return output;
+}
+// ─── repl_summary ────────────────────────────────────────────────────────────
+export const summary = tool({
+    description: "Generate a formatted summary of the REPL loop results for inclusion in " +
+        "the quality gate report and PR body. Call after all tasks are complete " +
+        "or when the loop is terminated.",
+    args: {},
+    async execute(args, context) {
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop data found.\n\nRun repl_init to start a loop, or this may have been cleaned up already.`;
+        }
+        return formatSummary(state);
+    },
+});

package/dist/tools/task.d.ts

@@ -7,6 +7,7 @@ export declare const finalize: {
         baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
         planFilename: import("zod").ZodOptional<import("zod").ZodString>;
         draft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        issueRefs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
     };
     execute(args: {
         commitMessage: string;
@@ -15,6 +16,7 @@ export declare const finalize: {
         baseBranch?: string | undefined;
         planFilename?: string | undefined;
         draft?: boolean | undefined;
+        issueRefs?: number[] | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 //# sourceMappingURL=task.d.ts.map

package/dist/tools/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AAyGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;CAqNnB,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AA+EA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;CA0OnB,CAAC"}