cortex-agents 2.3.1 → 4.0.0

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<{
+            all: "all";
+            open: "open";
+            closed: "closed";
+        }>>;
+        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?: "all" | "open" | "closed" | 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/plan.d.ts

@@ -1,32 +1,36 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type Client = PluginInput["client"];
 export declare const save: {
     description: string;
     args: {
         title: import("zod").ZodString;
         type: import("zod").ZodEnum<{
+            refactor: "refactor";
             feature: "feature";
             bugfix: "bugfix";
-            refactor: "refactor";
             spike: "spike";
             docs: "docs";
             architecture: "architecture";
         }>;
         content: import("zod").ZodString;
         tasks: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        branch: import("zod").ZodOptional<import("zod").ZodString>;
     };
     execute(args: {
         title: string;
-        type: "feature" | "bugfix" | "refactor" | "spike" | "docs" | "architecture";
+        type: "refactor" | "feature" | "bugfix" | "spike" | "docs" | "architecture";
         content: string;
         tasks?: string[] | undefined;
+        branch?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare const list: {
     description: string;
     args: {
         type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            refactor: "refactor";
             feature: "feature";
             bugfix: "bugfix";
-            refactor: "refactor";
             spike: "spike";
             docs: "docs";
             architecture: "architecture";
@@ -34,7 +38,7 @@ export declare const list: {
         }>>;
     };
     execute(args: {
-        type?: "feature" | "bugfix" | "refactor" | "spike" | "docs" | "architecture" | "all" | undefined;
+        type?: "refactor" | "feature" | "bugfix" | "spike" | "docs" | "architecture" | "all" | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare const load: {
@@ -55,5 +59,25 @@ export declare const delete_: {
         filename: string;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+/**
+ * Factory function that creates the plan_commit tool with access
+ * to the OpenCode client for toast notifications.
+ *
+ * Creates a git branch from plan metadata, stages .cortex/ artifacts,
+ * commits them, and writes the branch name back into the plan frontmatter.
+ */
+export declare function createCommit(client: Client): {
+    description: string;
+    args: {
+        planFilename: import("zod").ZodString;
+        branchType: import("zod").ZodOptional<import("zod").ZodString>;
+        branchName: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        planFilename: string;
+        branchType?: string | undefined;
+        branchName?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
 export { delete_ as delete };
 //# sourceMappingURL=plan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/tools/plan.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;CA2Df,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAkEf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAuBf,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAkBlB,CAAC;AAGH,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/tools/plan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAgBvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AA2BpC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;CAgEf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAkEf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CA6Bf,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAwBlB,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;EAsN1C;AAGD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}

package/dist/tools/plan.js

@@ -1,8 +1,11 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
+import { git } from "../utils/shell.js";
+import { TYPE_TO_PREFIX, parseFrontmatter, upsertFrontmatterField, } from "../utils/plan-extract.js";
 const CORTEX_DIR = ".cortex";
 const PLANS_DIR = "plans";
+const PROTECTED_BRANCHES = ["main", "master", "develop", "production", "staging"];
 function slugify(text) {
     return text
         .toLowerCase()
@@ -37,20 +40,25 @@ export const save = tool({
             .array(tool.schema.string())
             .optional()
             .describe("Optional list of tasks"),
+        branch: tool.schema
+            .string()
+            .optional()
+            .describe("Optional branch name to store in frontmatter (set by plan_commit)"),
     },
     async execute(args, context) {
-        const { title, type, content, tasks } = args;
+        const { title, type, content, tasks, branch } = args;
         const plansPath = ensureCortexDir(context.worktree);
         const datePrefix = getDatePrefix();
         const slug = slugify(title);
         const filename = `${datePrefix}-${type}-${slug}.md`;
         const filepath = path.join(plansPath, filename);
         // Build frontmatter
+        const branchLine = branch ? `\nbranch: ${branch}` : "";
         const frontmatter = `---
 title: "${title}"
 type: ${type}
 created: ${new Date().toISOString()}
-status: draft
+status: draft${branchLine}
 ---
 
 `;
@@ -144,7 +152,12 @@ export const load = tool({
     async execute(args, context) {
         const { filename } = args;
         const plansPath = path.join(context.worktree, CORTEX_DIR, PLANS_DIR);
-        const filepath = path.join(plansPath, filename);
+        const filepath = path.resolve(plansPath, filename);
+        const resolvedPlansDir = path.resolve(plansPath);
+        // Prevent path traversal (../ or absolute paths)
+        if (!filepath.startsWith(resolvedPlansDir + path.sep)) {
+            return `✗ Invalid plan filename: path traversal not allowed`;
+        }
         if (!fs.existsSync(filepath)) {
             return `✗ Plan not found: ${filename}
 
@@ -165,7 +178,12 @@ export const delete_ = tool({
     async execute(args, context) {
         const { filename } = args;
         const plansPath = path.join(context.worktree, CORTEX_DIR, PLANS_DIR);
-        const filepath = path.join(plansPath, filename);
+        const filepath = path.resolve(plansPath, filename);
+        const resolvedPlansDir = path.resolve(plansPath);
+        // Prevent path traversal (../ or absolute paths)
+        if (!filepath.startsWith(resolvedPlansDir + path.sep)) {
+            return `✗ Invalid plan filename: path traversal not allowed`;
+        }
         if (!fs.existsSync(filepath)) {
             return `✗ Plan not found: ${filename}`;
         }
@@ -173,5 +191,215 @@ export const delete_ = tool({
         return `✓ Deleted plan: ${filename}`;
     },
 });
+/**
+ * Factory function that creates the plan_commit tool with access
+ * to the OpenCode client for toast notifications.
+ *
+ * Creates a git branch from plan metadata, stages .cortex/ artifacts,
+ * commits them, and writes the branch name back into the plan frontmatter.
+ */
+export function createCommit(client) {
+    return tool({
+        description: "Create a git branch from a saved plan, commit .cortex/ artifacts to it, and " +
+            "write the branch name into the plan frontmatter. Keeps main clean.",
+        args: {
+            planFilename: tool.schema
+                .string()
+                .describe("Plan filename from .cortex/plans/ (e.g., '2026-02-26-feature-auth.md')"),
+            branchType: tool.schema
+                .string()
+                .optional()
+                .describe("Override branch prefix (default: derived from plan type)"),
+            branchName: tool.schema
+                .string()
+                .optional()
+                .describe("Override branch slug (default: derived from plan title)"),
+        },
+        async execute(args, context) {
+            const { planFilename, branchType, branchName: nameOverride } = args;
+            const cwd = context.worktree;
+            // ── 1. Validate: git repo ─────────────────────────────────
+            try {
+                await git(cwd, "rev-parse", "--git-dir");
+            }
+            catch {
+                return "✗ Error: Not in a git repository. Initialize git first.";
+            }
+            // ── 2. Read and parse the plan ────────────────────────────
+            const plansPath = path.join(cwd, CORTEX_DIR, PLANS_DIR);
+            const filepath = path.resolve(plansPath, planFilename);
+            const resolvedPlansDir = path.resolve(plansPath);
+            // Prevent path traversal (../ or absolute paths)
+            if (!filepath.startsWith(resolvedPlansDir + path.sep)) {
+                return `✗ Invalid plan filename: path traversal not allowed`;
+            }
+            if (!fs.existsSync(filepath)) {
+                return `✗ Plan not found: ${planFilename}
+
+Use plan_list to see available plans.`;
+            }
+            let planContent = fs.readFileSync(filepath, "utf-8");
+            const fm = parseFrontmatter(planContent);
+            if (!fm) {
+                return `✗ Plan has no frontmatter: ${planFilename}
+
+Expected YAML frontmatter with title and type fields.`;
+            }
+            const planTitle = fm.title || "untitled";
+            const planType = fm.type || "feature";
+            // ── 3. Determine branch name ──────────────────────────────
+            const VALID_PREFIXES = Object.values(TYPE_TO_PREFIX);
+            const rawPrefix = branchType || TYPE_TO_PREFIX[planType] || "feature";
+            const prefix = VALID_PREFIXES.includes(rawPrefix) ? rawPrefix : "feature";
+            // Always sanitize name through slugify (even overrides)
+            const slug = slugify(nameOverride || planTitle);
+            const fullBranchName = `${prefix}/${slug}`;
+            // ── 4. Check current branch ───────────────────────────────
+            let currentBranch = "";
+            try {
+                const { stdout } = await git(cwd, "branch", "--show-current");
+                currentBranch = stdout.trim();
+            }
+            catch {
+                currentBranch = "";
+            }
+            const isOnProtected = PROTECTED_BRANCHES.includes(currentBranch);
+            let branchCreated = false;
+            // ── 5. Create or switch to branch ─────────────────────────
+            if (isOnProtected || !currentBranch) {
+                // Try to create the branch
+                try {
+                    await git(cwd, "checkout", "-b", fullBranchName);
+                    branchCreated = true;
+                }
+                catch {
+                    // Branch may already exist — try switching to it
+                    try {
+                        await git(cwd, "checkout", fullBranchName);
+                    }
+                    catch (switchErr) {
+                        try {
+                            await client.tui.showToast({
+                                body: {
+                                    title: `Plan Commit: ${planFilename}`,
+                                    message: `Failed to create/switch branch: ${switchErr.message || switchErr}`,
+                                    variant: "error",
+                                    duration: 8000,
+                                },
+                            });
+                        }
+                        catch {
+                            // Toast failure is non-fatal
+                        }
+                        return `✗ Error creating branch '${fullBranchName}': ${switchErr.message || switchErr}
+
+You may have uncommitted changes. Commit or stash them first.`;
+                    }
+                }
+            }
+            // If already on a non-protected branch, skip branch creation
+            // ── 6. Update plan frontmatter with branch ────────────────
+            // If we created/switched to a new branch → use that name
+            // If already on a non-protected branch → use whatever we're on
+            const targetBranch = (isOnProtected || branchCreated) ? fullBranchName : currentBranch;
+            planContent = upsertFrontmatterField(planContent, "branch", targetBranch);
+            fs.writeFileSync(filepath, planContent);
+            // ── 7. Stage .cortex/ directory ───────────────────────────
+            try {
+                await git(cwd, "add", path.join(cwd, CORTEX_DIR));
+            }
+            catch (stageErr) {
+                return `✗ Error staging .cortex/ directory: ${stageErr.message || stageErr}`;
+            }
+            // ── 8. Commit ─────────────────────────────────────────────
+            const commitMsg = `chore(plan): ${planTitle}`;
+            let commitHash = "";
+            try {
+                // Check if there's anything staged
+                const { stdout: statusOut } = await git(cwd, "status", "--porcelain");
+                const stagedLines = statusOut
+                    .trim()
+                    .split("\n")
+                    .filter((l) => l && l[0] !== " " && l[0] !== "?");
+                if (stagedLines.length === 0) {
+                    // Nothing to commit — plan already committed
+                    try {
+                        const { stdout: hashOut } = await git(cwd, "rev-parse", "--short", "HEAD");
+                        commitHash = hashOut.trim();
+                    }
+                    catch {
+                        commitHash = "(unknown)";
+                    }
+                    try {
+                        await client.tui.showToast({
+                            body: {
+                                title: `Plan: ${targetBranch}`,
+                                message: "Already committed — no new changes",
+                                variant: "info",
+                                duration: 4000,
+                            },
+                        });
+                    }
+                    catch {
+                        // Toast failure is non-fatal
+                    }
+                    return `✓ Plan already committed on branch: ${targetBranch}
+
+Branch: ${targetBranch}
+Commit: ${commitHash} (no new changes)
+Plan: ${planFilename}
+
+The plan branch is ready for implementation.
+Use worktree_create or switch to the Implement agent.`;
+                }
+                await git(cwd, "commit", "-m", commitMsg);
+                const { stdout: hashOut } = await git(cwd, "rev-parse", "--short", "HEAD");
+                commitHash = hashOut.trim();
+            }
+            catch (commitErr) {
+                try {
+                    await client.tui.showToast({
+                        body: {
+                            title: `Plan Commit`,
+                            message: `Commit failed: ${commitErr.message || commitErr}`,
+                            variant: "error",
+                            duration: 8000,
+                        },
+                    });
+                }
+                catch {
+                    // Toast failure is non-fatal
+                }
+                return `✗ Error committing: ${commitErr.message || commitErr}`;
+            }
+            // ── 9. Success notification ───────────────────────────────
+            try {
+                await client.tui.showToast({
+                    body: {
+                        title: `Plan Committed`,
+                        message: `${targetBranch} — ${commitHash}`,
+                        variant: "success",
+                        duration: 5000,
+                    },
+                });
+            }
+            catch {
+                // Toast failure is non-fatal
+            }
+            return `✓ Plan committed to branch
+
+Branch: ${targetBranch}${branchCreated ? " (created)" : ""}
+Commit: ${commitHash} — ${commitMsg}
+Plan: ${planFilename}
+
+The plan and .cortex/ artifacts are committed on '${targetBranch}'.
+Main branch is clean.
+
+Next steps:
+  • Switch to Implement agent to begin coding
+  • Or use worktree_create to work in an isolated copy`;
+        },
+    });
+}
 // Export with underscore suffix to avoid reserved word
 export { delete_ as delete };

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"}