cortex-agents 3.4.0 → 4.0.1

package/dist/tools/quality-gate.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Quality Gate Summary Tool
+ *
+ * Aggregates sub-agent findings into a unified report with severity sorting,
+ * go/no-go recommendation, and PR body content.
+ */
+export declare const qualityGateSummary: {
+    description: string;
+    args: {
+        scope: import("zod").ZodOptional<import("zod").ZodString>;
+        testing: import("zod").ZodOptional<import("zod").ZodString>;
+        security: import("zod").ZodOptional<import("zod").ZodString>;
+        audit: import("zod").ZodOptional<import("zod").ZodString>;
+        perf: import("zod").ZodOptional<import("zod").ZodString>;
+        devops: import("zod").ZodOptional<import("zod").ZodString>;
+        docsWriter: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        scope?: string | undefined;
+        testing?: string | undefined;
+        security?: string | undefined;
+        audit?: string | undefined;
+        perf?: string | undefined;
+        devops?: string | undefined;
+        docsWriter?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=quality-gate.d.ts.map

package/dist/tools/quality-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-gate.d.ts","sourceRoot":"","sources":["../../src/tools/quality-gate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6CH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;CA+I7B,CAAC"}

package/dist/tools/quality-gate.js

@@ -0,0 +1,233 @@
+/**
+ * Quality Gate Summary Tool
+ *
+ * Aggregates sub-agent findings into a unified report with severity sorting,
+ * go/no-go recommendation, and PR body content.
+ */
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const QUALITY_GATE_FILE = "quality-gate.json";
+// ─── Severity ordering ───────────────────────────────────────────────────────
+const SEVERITY_ORDER = {
+    CRITICAL: 0,
+    HIGH: 1,
+    MEDIUM: 2,
+    LOW: 3,
+    INFO: 4,
+};
+// ─── quality_gate_summary ────────────────────────────────────────────────────
+export const qualityGateSummary = tool({
+    description: "Aggregate sub-agent quality gate findings into a unified report. " +
+        "Parses findings from @testing, @security, @audit, @perf, @devops, and @docs-writer, " +
+        "sorts by severity, provides a go/no-go recommendation, and generates PR body content. " +
+        "Pass each agent's raw report text as a separate entry.",
+    args: {
+        scope: tool.schema
+            .string()
+            .optional()
+            .describe("Change scope classification: trivial, low, standard, high"),
+        testing: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @testing sub-agent"),
+        security: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @security sub-agent"),
+        audit: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @audit sub-agent"),
+        perf: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @perf sub-agent"),
+        devops: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @devops sub-agent"),
+        docsWriter: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @docs-writer sub-agent"),
+    },
+    async execute(args, context) {
+        const cwd = context.worktree;
+        const reports = [];
+        // Parse each provided report
+        const agentEntries = [
+            ["testing", args.testing],
+            ["security", args.security],
+            ["audit", args.audit],
+            ["perf", args.perf],
+            ["devops", args.devops],
+            ["docs-writer", args.docsWriter],
+        ];
+        for (const [agent, raw] of agentEntries) {
+            if (!raw)
+                continue;
+            reports.push(parseReport(agent, raw));
+        }
+        if (reports.length === 0) {
+            return `\u2717 No sub-agent reports provided. Pass at least one agent report to aggregate.`;
+        }
+        // Collect all findings and sort by severity
+        const allFindings = reports.flatMap((r) => r.findings);
+        allFindings.sort((a, b) => (SEVERITY_ORDER[a.severity] ?? 99) - (SEVERITY_ORDER[b.severity] ?? 99));
+        // Determine recommendation
+        const hasCritical = allFindings.some((f) => f.severity === "CRITICAL");
+        const hasHigh = allFindings.some((f) => f.severity === "HIGH");
+        const hasMedium = allFindings.some((f) => f.severity === "MEDIUM");
+        let recommendation;
+        if (hasCritical || hasHigh) {
+            recommendation = "NO-GO";
+        }
+        else if (hasMedium) {
+            recommendation = "GO-WITH-WARNINGS";
+        }
+        else {
+            recommendation = "GO";
+        }
+        // Build state for persistence
+        const state = {
+            timestamp: new Date().toISOString(),
+            scope: args.scope ?? "unknown",
+            reports,
+            recommendation,
+        };
+        // Persist state
+        persistState(cwd, state);
+        // Format output
+        const lines = [];
+        lines.push(`\u2713 Quality Gate Summary`);
+        lines.push("");
+        lines.push(`**Recommendation: ${recommendation}**`);
+        lines.push(`Scope: ${args.scope ?? "unknown"}`);
+        lines.push(`Agents: ${reports.map((r) => r.agent).join(", ")}`);
+        lines.push(`Total findings: ${allFindings.length}`);
+        lines.push("");
+        // Per-agent verdicts
+        lines.push("## Agent Results");
+        for (const report of reports) {
+            const agentFindings = report.findings;
+            const counts = countBySeverity(agentFindings);
+            lines.push(`- **@${report.agent}**: ${report.verdict} — ${formatCounts(counts)}`);
+        }
+        // All findings sorted by severity
+        if (allFindings.length > 0) {
+            lines.push("");
+            lines.push("## Findings (sorted by severity)");
+            for (const finding of allFindings) {
+                const loc = finding.location ? ` (${finding.location})` : "";
+                lines.push(`- **[${finding.severity}]** @${finding.agent}: ${finding.title}${loc}`);
+                if (finding.description) {
+                    lines.push(`  ${finding.description.substring(0, 200)}`);
+                }
+            }
+        }
+        // Blockers
+        const blockers = allFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH");
+        if (blockers.length > 0) {
+            lines.push("");
+            lines.push("## Blockers (must fix before merge)");
+            for (const b of blockers) {
+                lines.push(`- **[${b.severity}]** @${b.agent}: ${b.title}`);
+            }
+        }
+        // PR body section
+        lines.push("");
+        lines.push("## PR Body Quality Gate Section");
+        lines.push("```");
+        lines.push("## Quality Gate");
+        for (const report of reports) {
+            const counts = countBySeverity(report.findings);
+            lines.push(`- ${capitalize(report.agent)}: ${report.verdict} — ${formatCounts(counts)}`);
+        }
+        lines.push(`- **Recommendation: ${recommendation}**`);
+        lines.push("```");
+        return lines.join("\n");
+    },
+});
+// ─── Parsing helpers ─────────────────────────────────────────────────────────
+function parseReport(agent, raw) {
+    const findings = [];
+    // Extract verdict
+    let verdict = "Unknown";
+    const verdictMatch = raw.match(/\*\*Verdict\*\*:\s*(.+)/i)
+        ?? raw.match(/Verdict:\s*(.+)/i);
+    if (verdictMatch) {
+        verdict = verdictMatch[1].trim();
+    }
+    // Extract findings by severity markers
+    const findingRegex = /####?\s*\[(CRITICAL|HIGH|MEDIUM|LOW|INFO|BLOCKING|WARNING|ERROR|SUGGESTION|NITPICK|PRAISE)\]\s*(.+)/gi;
+    let match;
+    while ((match = findingRegex.exec(raw)) !== null) {
+        const rawSeverity = match[1].toUpperCase();
+        const title = match[2].trim();
+        // Normalize severity
+        let severity;
+        switch (rawSeverity) {
+            case "CRITICAL":
+            case "BLOCKING":
+            case "ERROR":
+                severity = "CRITICAL";
+                break;
+            case "HIGH":
+                severity = "HIGH";
+                break;
+            case "MEDIUM":
+            case "WARNING":
+            case "SUGGESTION":
+                severity = "MEDIUM";
+                break;
+            case "LOW":
+            case "NITPICK":
+                severity = "LOW";
+                break;
+            default:
+                severity = "INFO";
+        }
+        // Try to extract location from lines following the finding
+        const afterMatch = raw.substring(match.index + match[0].length, match.index + match[0].length + 500);
+        const locationMatch = afterMatch.match(/\*\*Location\*\*:\s*`?([^`\n]+)/i)
+            ?? afterMatch.match(/\*\*File\*\*:\s*`?([^`\n]+)/i);
+        const descMatch = afterMatch.match(/\*\*Description\*\*:\s*(.+)/i);
+        findings.push({
+            agent,
+            severity,
+            title,
+            location: locationMatch?.[1]?.trim(),
+            description: descMatch?.[1]?.trim() ?? "",
+        });
+    }
+    return { agent, verdict, findings, raw };
+}
+function countBySeverity(findings) {
+    const counts = {};
+    for (const f of findings) {
+        counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+    }
+    return counts;
+}
+function formatCounts(counts) {
+    const parts = [];
+    for (const sev of ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]) {
+        if (counts[sev]) {
+            parts.push(`${counts[sev]} ${sev.toLowerCase()}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(", ") : "no findings";
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function persistState(cwd, state) {
+    const dir = path.join(cwd, CORTEX_DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filepath = path.join(dir, QUALITY_GATE_FILE);
+    fs.writeFileSync(filepath, JSON.stringify(state, null, 2));
+}

package/dist/tools/repl.d.ts

@@ -42,6 +42,11 @@ export declare const report: {
         detail: string;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+export declare const resume: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
 export declare const summary: {
     description: string;
     args: {};

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

@@ -1 +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"}
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/tools/repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0BH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAwGf,CAAC;AAIH,eAAO,MAAM,MAAM;;;;CA0BjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;CAwCjB,CAAC;AAkFH,eAAO,MAAM,MAAM;;;;CA+CjB,CAAC;AAIH,eAAO,MAAM,OAAO;;;;CAclB,CAAC"}

package/dist/tools/repl.js

@@ -10,7 +10,7 @@
 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";
+import { parseTasksWithAC, detectCommands, readCortexConfig, readReplState, writeReplState, getNextTask, getCurrentTask, isLoopComplete, detectIncompleteState, formatProgress, formatSummary, } from "../utils/repl.js";
 const CORTEX_DIR = ".cortex";
 const PLANS_DIR = "plans";
 // ─── repl_init ───────────────────────────────────────────────────────────────
@@ -36,8 +36,9 @@ export const init = tool({
             .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;
+        const config = readCortexConfig(cwd);
+        const { planFilename, buildCommand, testCommand, maxRetries = config.maxRetries ?? 3 } = args;
         // 1. Validate plan filename
         if (!planFilename || planFilename === "." || planFilename === "..") {
             return `\u2717 Error: Invalid plan filename.`;
@@ -53,9 +54,9 @@ export const init = tool({
             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) {
+        // 2. Parse tasks from plan (with acceptance criteria)
+        const parsedTasks = parseTasksWithAC(planContent);
+        if (parsedTasks.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)
@@ -63,9 +64,10 @@ export const init = tool({
         const finalBuild = buildCommand ?? detected.buildCommand;
         const finalTest = testCommand ?? detected.testCommand;
         // 4. Build initial state
-        const tasks = taskDescriptions.map((desc, i) => ({
+        const tasks = parsedTasks.map((parsed, i) => ({
             index: i,
-            description: desc,
+            description: parsed.description,
+            acceptanceCriteria: parsed.acceptanceCriteria,
             status: "pending",
             retries: 0,
             iterations: [],
@@ -120,6 +122,7 @@ export const status = tool({
             const next = getNextTask(state);
             if (next) {
                 next.status = "in_progress";
+                next.startedAt = new Date().toISOString();
                 state.currentTaskIndex = next.index;
                 writeReplState(context.worktree, state);
             }
@@ -179,6 +182,7 @@ function processReport(state, task, result, detail, cwd) {
     switch (result) {
         case "pass": {
             task.status = "passed";
+            task.completedAt = new Date().toISOString();
             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)}`;
@@ -190,6 +194,7 @@ function processReport(state, task, result, detail, cwd) {
             if (task.retries >= state.maxRetries) {
                 // Retries exhausted
                 task.status = "failed";
+                task.completedAt = new Date().toISOString();
                 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 {
@@ -204,6 +209,7 @@ function processReport(state, task, result, detail, cwd) {
         }
         case "skip": {
             task.status = "skipped";
+            task.completedAt = new Date().toISOString();
             output = `\u2298 Task #${taskNum} SKIPPED\n  "${taskDesc}"\n  Reason: ${detail.substring(0, 200)}`;
             break;
         }
@@ -212,6 +218,7 @@ function processReport(state, task, result, detail, cwd) {
     const next = getNextTask(state);
     if (next) {
         next.status = "in_progress";
+        next.startedAt = new Date().toISOString();
         state.currentTaskIndex = next.index;
         output += `\n\n\u2192 Next: Task #${next.index + 1} "${next.description}"`;
     }
@@ -224,6 +231,50 @@ function processReport(state, task, result, detail, cwd) {
     writeReplState(cwd, state);
     return output;
 }
+// ─── repl_resume ─────────────────────────────────────────────────────────────
+export const resume = tool({
+    description: "Detect and resume an interrupted REPL loop. Checks for incomplete state " +
+        "in .cortex/repl-state.json and offers to continue from where it left off. " +
+        "Call this at the start of a session to recover from crashes or context loss.",
+    args: {},
+    async execute(args, context) {
+        const state = detectIncompleteState(context.worktree);
+        if (!state) {
+            return `\u2717 No interrupted REPL loop found.\n\nEither no loop has been started, or the previous loop completed normally.`;
+        }
+        const total = state.tasks.length;
+        const passed = state.tasks.filter((t) => t.status === "passed").length;
+        const failed = state.tasks.filter((t) => t.status === "failed").length;
+        const skipped = state.tasks.filter((t) => t.status === "skipped").length;
+        const done = passed + failed + skipped;
+        const current = getCurrentTask(state);
+        const next = getNextTask(state);
+        const lines = [];
+        lines.push(`\u2713 Interrupted REPL loop detected`);
+        lines.push("");
+        lines.push(`Plan: ${state.planFilename}`);
+        lines.push(`Progress: ${done}/${total} tasks completed (${passed} passed, ${failed} failed, ${skipped} skipped)`);
+        lines.push(`Started: ${state.startedAt}`);
+        if (current) {
+            lines.push("");
+            lines.push(`Interrupted task (#${current.index + 1}):`);
+            lines.push(`  "${current.description}"`);
+            lines.push(`  Status: in_progress (${current.retries} retries so far)`);
+            if (current.iterations.length > 0) {
+                const lastIter = current.iterations[current.iterations.length - 1];
+                lines.push(`  Last attempt: ${lastIter.result} — ${lastIter.detail.substring(0, 100)}`);
+            }
+        }
+        else if (next) {
+            lines.push("");
+            lines.push(`Next pending task (#${next.index + 1}):`);
+            lines.push(`  "${next.description}"`);
+        }
+        lines.push("");
+        lines.push(`\u2192 Run repl_status to continue the loop from where it left off.`);
+        return lines.join("\n");
+    },
+});
 // ─── repl_summary ────────────────────────────────────────────────────────────
 export const summary = tool({
     description: "Generate a formatted summary of the REPL loop results for inclusion in " +

package/dist/tools/worktree.d.ts

@@ -1,6 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 type Client = PluginInput["client"];
-type Shell = PluginInput["$"];
 /**
  * Factory function that creates the worktree_create tool with access
  * to the OpenCode client for toast notifications.
@@ -10,18 +9,20 @@ export declare function createCreate(client: Client): {
     args: {
         name: import("zod").ZodString;
         type: import("zod").ZodEnum<{
+            refactor: "refactor";
             feature: "feature";
             bugfix: "bugfix";
             hotfix: "hotfix";
-            refactor: "refactor";
             spike: "spike";
             docs: "docs";
             test: "test";
         }>;
+        fromBranch: import("zod").ZodOptional<import("zod").ZodString>;
     };
     execute(args: {
         name: string;
-        type: "feature" | "bugfix" | "hotfix" | "refactor" | "spike" | "docs" | "test";
+        type: "refactor" | "feature" | "bugfix" | "hotfix" | "spike" | "docs" | "test";
+        fromBranch?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare const list: {
@@ -31,7 +32,7 @@ export declare const list: {
 };
 /**
  * Factory function that creates the worktree_remove tool with access
- * to the OpenCode client for toast notifications and PTY cleanup.
+ * to the OpenCode client for toast notifications.
  */
 export declare function createRemove(client: Client): {
     description: string;
@@ -53,33 +54,5 @@ export declare const open: {
         name: string;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
-/**
- * Factory function that creates the worktree_launch tool with access
- * to the OpenCode client (for PTY and toast) and shell.
- *
- * This uses a closure to capture `client` and `shell` since ToolContext
- * does not provide access to the OpenCode client API.
- */
-export declare function createLaunch(client: Client, shell: Shell): {
-    description: string;
-    args: {
-        name: import("zod").ZodString;
-        mode: import("zod").ZodEnum<{
-            terminal: "terminal";
-            pty: "pty";
-            background: "background";
-        }>;
-        plan: import("zod").ZodOptional<import("zod").ZodString>;
-        agent: import("zod").ZodOptional<import("zod").ZodString>;
-        prompt: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        name: string;
-        mode: "terminal" | "pty" | "background";
-        plan?: string | undefined;
-        agent?: string | undefined;
-        prompt?: string | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
 export {};
 //# sourceMappingURL=worktree.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/tools/worktree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAiBvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AACpC,KAAK,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;AAE9B;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;EAuF1C;AAED,eAAO,MAAM,IAAI;;;;CAiCf,CAAC;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;EAkI1C;AAED,eAAO,MAAM,IAAI;;;;;;;;CAgDf,CAAC;AA8UH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;;;;;;;;;EAsIxD"}
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/tools/worktree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAQvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;EA0H1C;AAED,eAAO,MAAM,IAAI;;;;CAiCf,CAAC;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;EA0F1C;AAED,eAAO,MAAM,IAAI;;;;;;;;CAgDf,CAAC"}