cortex-agents 2.2.0 → 2.3.1

package/dist/index.js

@@ -6,7 +6,7 @@ import * as plan from "./tools/plan";
 import * as session from "./tools/session";
 import * as docs from "./tools/docs";
 import * as task from "./tools/task";
-// Agent descriptions for handover toast notifications
+// ─── Agent Descriptions (for handover toasts) ───────────────────────────────
 const AGENT_DESCRIPTIONS = {
     build: "Development mode — ready to implement",
     plan: "Planning mode — read-only analysis",
@@ -16,21 +16,110 @@ const AGENT_DESCRIPTIONS = {
     security: "Security subagent — vulnerability audit",
     devops: "DevOps subagent — CI/CD and deployment",
 };
+const TOOL_NOTIFICATIONS = {
+    task_finalize: {
+        successTitle: "Task Finalized",
+        successMsg: (args) => `Committed & pushed: ${(args.commitMessage ?? "").substring(0, 50)}`,
+        errorTitle: "Finalization Failed",
+        errorMsg: (_, out) => out
+            .replace(/^✗\s*/, "")
+            .split("\n")[0]
+            .substring(0, 100),
+        successDuration: 5000,
+        errorDuration: 10000,
+    },
+    plan_save: {
+        successTitle: "Plan Saved",
+        successMsg: (args) => args.title ?? "Plan saved",
+        errorTitle: "Plan Save Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    plan_delete: {
+        successTitle: "Plan Deleted",
+        successMsg: (args) => args.filename ?? "Plan deleted",
+        errorTitle: "Plan Delete Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    session_save: {
+        successTitle: "Session Saved",
+        successMsg: () => "Session summary recorded",
+        errorTitle: "Session Save Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    docs_save: {
+        successTitle: "Documentation Saved",
+        successMsg: (args) => `${args.type ?? "doc"}: ${args.title ?? "Untitled"}`,
+        errorTitle: "Doc Save Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    docs_init: {
+        successTitle: "Docs Initialized",
+        successMsg: () => "Documentation directory created",
+        errorTitle: "Docs Init Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    cortex_init: {
+        successTitle: "Project Initialized",
+        successMsg: () => ".cortex directory created",
+        errorTitle: "Init Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    cortex_configure: {
+        successTitle: "Models Configured",
+        successMsg: (args) => `Primary: ${args.primaryModel?.split("/").pop() || "set"}`,
+        errorTitle: "Configure Failed",
+        errorMsg: (_, out) => out.substring(0, 100),
+    },
+    branch_switch: {
+        successTitle: "Branch Switched",
+        successMsg: (args) => `Now on ${args.branch ?? "branch"}`,
+        errorTitle: "Branch Switch Failed",
+        errorMsg: (_, out) => out
+            .replace(/^✗\s*/, "")
+            .split("\n")[0]
+            .substring(0, 100),
+    },
+};
+// ─── Error Message Extraction ────────────────────────────────────────────────
+//
+// Extracts a human-readable message from the session error union type
+// (ProviderAuthError | UnknownError | MessageOutputLengthError |
+//  MessageAbortedError | ApiError).
+function extractErrorMessage(error) {
+    if (!error)
+        return "An unknown error occurred";
+    const msg = typeof error.data?.message === "string" ? error.data.message : "";
+    switch (error.name) {
+        case "ProviderAuthError":
+            return `Auth error: ${msg || "Provider authentication failed"}`;
+        case "UnknownError":
+            return msg || "An unknown error occurred";
+        case "MessageOutputLengthError":
+            return "Output length exceeded — try compacting the session";
+        case "MessageAbortedError":
+            return `Aborted: ${msg || "Message was aborted"}`;
+        case "APIError":
+            return `API error: ${msg || "Request failed"}`;
+        default:
+            return `Error: ${error.name}`;
+    }
+}
+// ─── Plugin Entry ────────────────────────────────────────────────────────────
 export const CortexPlugin = async (ctx) => {
     return {
         tool: {
             // Cortex tools - .cortex directory management
             cortex_init: cortex.init,
             cortex_status: cortex.status,
-            // Worktree tools - git worktree management
-            worktree_create: worktree.create,
+            cortex_configure: cortex.configure,
+            // Worktree tools - git worktree management (factories for toast notifications)
+            worktree_create: worktree.createCreate(ctx.client),
             worktree_list: worktree.list,
-            worktree_remove: worktree.remove,
+            worktree_remove: worktree.createRemove(ctx.client),
             worktree_open: worktree.open,
-            // Dynamic tool: needs client + shell via factory (closure injection)
             worktree_launch: worktree.createLaunch(ctx.client, ctx.$),
-            // Branch tools - git branch operations
-            branch_create: branch.create,
+            // Branch tools - git branch operations (factory for toast notifications)
+            branch_create: branch.createCreate(ctx.client),
             branch_status: branch.status,
             branch_switch: branch.switch_,
             // Plan tools - implementation plan persistence
@@ -50,9 +139,49 @@ export const CortexPlugin = async (ctx) => {
             // Task tools - finalize workflow (commit, push, PR)
             task_finalize: task.finalize,
         },
-        // Agent handover toast notifications
+        // ── Post-execution toast notifications ────────────────────────────────
+        //
+        // Fires after every tool execution. Uses the TOOL_NOTIFICATIONS map
+        // to determine which tools get toasts and what content to display.
+        // Tools with existing factory-based toasts are excluded from the map.
+        "tool.execute.after": async (input, output) => {
+            const config = TOOL_NOTIFICATIONS[input.tool];
+            if (!config)
+                return; // No notification configured for this tool
+            try {
+                const result = output.output;
+                const isSuccess = result.startsWith("✓");
+                const isError = result.startsWith("✗");
+                if (isSuccess) {
+                    await ctx.client.tui.showToast({
+                        body: {
+                            title: config.successTitle,
+                            message: config.successMsg(input.args, result),
+                            variant: "success",
+                            duration: config.successDuration ?? 4000,
+                        },
+                    });
+                }
+                else if (isError) {
+                    await ctx.client.tui.showToast({
+                        body: {
+                            title: config.errorTitle,
+                            message: config.errorMsg(input.args, result),
+                            variant: "error",
+                            duration: config.errorDuration ?? 8000,
+                        },
+                    });
+                }
+                // Informational or warning outputs (⚠) — no toast to avoid noise
+            }
+            catch {
+                // Toast failure is non-fatal
+            }
+        },
+        // ── Event-driven notifications ───────────────────────────────────────
         async event({ event }) {
             try {
+                // Agent handover notifications
                 if (event.type === "message.part.updated" &&
                     "part" in event.properties &&
                     event.properties.part.type === "agent") {
@@ -67,6 +196,43 @@ export const CortexPlugin = async (ctx) => {
                         },
                     });
                 }
+                // Session error notifications
+                if (event.type === "session.error") {
+                    const rawError = event.properties.error;
+                    // Runtime validation before cast — ensure error has expected shape
+                    const error = rawError &&
+                        typeof rawError === "object" &&
+                        "name" in rawError &&
+                        typeof rawError.name === "string"
+                        ? rawError
+                        : undefined;
+                    const message = extractErrorMessage(error);
+                    await ctx.client.tui.showToast({
+                        body: {
+                            title: "Session Error",
+                            message,
+                            variant: "error",
+                            duration: 10000,
+                        },
+                    });
+                }
+                // PTY exited notifications (relevant for worktree terminal sessions)
+                if (event.type === "pty.exited") {
+                    const rawExitCode = event.properties.exitCode;
+                    const exitCode = typeof rawExitCode === "number" && Number.isInteger(rawExitCode)
+                        ? rawExitCode
+                        : -1;
+                    await ctx.client.tui.showToast({
+                        body: {
+                            title: "Terminal Exited",
+                            message: exitCode === 0
+                                ? "Terminal session completed successfully"
+                                : `Terminal exited with code ${exitCode}`,
+                            variant: exitCode === 0 ? "success" : "warning",
+                            duration: exitCode === 0 ? 4000 : 8000,
+                        },
+                    });
+                }
             }
             catch {
                 // Toast failure is non-fatal — silently ignore

package/dist/registry.d.ts

@@ -19,11 +19,11 @@ export interface ModelEntry {
 }
 export declare const MODEL_REGISTRY: ModelEntry[];
 /** Primary agents receive the best available model */
-export declare const PRIMARY_AGENTS: readonly ["build", "plan", "debug"];
+export declare const PRIMARY_AGENTS: readonly ["build", "plan", "debug", "review"];
 /** Subagents receive a fast/cost-effective model */
 export declare const SUBAGENTS: readonly ["fullstack", "testing", "security", "devops"];
 /** All agent names combined */
-export declare const ALL_AGENTS: readonly ["build", "plan", "debug", "fullstack", "testing", "security", "devops"];
+export declare const ALL_AGENTS: readonly ["build", "plan", "debug", "review", "fullstack", "testing", "security", "devops"];
 /**
  * Build the interactive choices list for primary model selection.
  * Shows premium and standard tier models (excluding fast).

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,UAAU;IACzB,uDAAuD;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IACtC,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,cAAc,EAAE,UAAU,EAuGtC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,cAAc,qCAAsC,CAAC;AAElE,oDAAoD;AACpD,eAAO,MAAM,SAAS,yDAA0D,CAAC;AAEjF,+BAA+B;AAC/B,eAAO,MAAM,UAAU,mFAA6C,CAAC;AAErE;;;GAGG;AACH,wBAAgB,iBAAiB;;;;IAMhC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM;;;;IAcxD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,UAAU;IACzB,uDAAuD;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IACtC,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,cAAc,EAAE,UAAU,EAuGtC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,cAAc,+CAAgD,CAAC;AAE5E,oDAAoD;AACpD,eAAO,MAAM,SAAS,yDAA0D,CAAC;AAEjF,+BAA+B;AAC/B,eAAO,MAAM,UAAU,6FAA6C,CAAC;AAErE;;;GAGG;AACH,wBAAgB,iBAAiB;;;;IAMhC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM;;;;IAcxD"}

package/dist/registry.js

@@ -105,7 +105,7 @@ export const MODEL_REGISTRY = [
     },
 ];
 /** Primary agents receive the best available model */
-export const PRIMARY_AGENTS = ["build", "plan", "debug"];
+export const PRIMARY_AGENTS = ["build", "plan", "debug", "review"];
 /** Subagents receive a fast/cost-effective model */
 export const SUBAGENTS = ["fullstack", "testing", "security", "devops"];
 /** All agent names combined */

package/dist/tools/branch.d.ts

@@ -1,4 +1,10 @@
-export declare const create: {
+import type { PluginInput } from "@opencode-ai/plugin";
+type Client = PluginInput["client"];
+/**
+ * Factory function that creates the branch_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export declare function createCreate(client: Client): {
     description: string;
     args: {
         name: import("zod").ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/tools/branch.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;CA8CjB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAiGjB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAmClB,CAAC;AAGH,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/tools/branch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;EA0E1C;AAED,eAAO,MAAM,MAAM;;;;CAkGjB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAmClB,CAAC;AAGH,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}

package/dist/tools/branch.js

@@ -1,57 +1,91 @@
 import { tool } from "@opencode-ai/plugin";
+import { git } from "../utils/shell.js";
 const PROTECTED_BRANCHES = ["main", "master", "develop", "production", "staging"];
-export const create = tool({
-    description: "Create and checkout a new git branch with proper naming convention",
-    args: {
-        name: tool.schema
-            .string()
-            .describe("Branch name slug (e.g., 'user-authentication', 'fix-login')"),
-        type: tool.schema
-            .enum(["feature", "bugfix", "hotfix", "refactor", "docs", "test", "chore"])
-            .describe("Branch type - determines prefix"),
-    },
-    async execute(args, context) {
-        const { name, type } = args;
-        const branchName = `${type}/${name}`;
-        // Check if we're in a git repository
-        try {
-            await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
-        }
-        catch {
-            return "✗ Error: Not in a git repository";
-        }
-        // Check if branch already exists
-        try {
-            const branches = await Bun.$ `git branch --list ${branchName}`.cwd(context.worktree).text();
-            if (branches.trim()) {
-                return `✗ Error: Branch '${branchName}' already exists.
+/**
+ * Factory function that creates the branch_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export function createCreate(client) {
+    return tool({
+        description: "Create and checkout a new git branch with proper naming convention",
+        args: {
+            name: tool.schema
+                .string()
+                .describe("Branch name slug (e.g., 'user-authentication', 'fix-login')"),
+            type: tool.schema
+                .enum(["feature", "bugfix", "hotfix", "refactor", "docs", "test", "chore"])
+                .describe("Branch type - determines prefix"),
+        },
+        async execute(args, context) {
+            const { name, type } = args;
+            const branchName = `${type}/${name}`;
+            // Check if we're in a git repository
+            try {
+                await git(context.worktree, "rev-parse", "--git-dir");
+            }
+            catch {
+                return "✗ Error: Not in a git repository";
+            }
+            // Check if branch already exists
+            try {
+                const { stdout } = await git(context.worktree, "branch", "--list", branchName);
+                if (stdout.trim()) {
+                    return `✗ Error: Branch '${branchName}' already exists.
 
 Use branch_switch to switch to it, or choose a different name.`;
+                }
             }
-        }
-        catch {
-            // Ignore error, branch check is optional
-        }
-        // Create and checkout the branch
-        try {
-            await Bun.$ `git checkout -b ${branchName}`.cwd(context.worktree);
-        }
-        catch (error) {
-            return `✗ Error creating branch: ${error.message || error}`;
-        }
-        return `✓ Created and switched to branch: ${branchName}
+            catch {
+                // Ignore error, branch check is optional
+            }
+            // Create and checkout the branch
+            try {
+                await git(context.worktree, "checkout", "-b", branchName);
+            }
+            catch (error) {
+                try {
+                    await client.tui.showToast({
+                        body: {
+                            title: `Branch: ${branchName}`,
+                            message: `Failed to create: ${error.message || error}`,
+                            variant: "error",
+                            duration: 8000,
+                        },
+                    });
+                }
+                catch {
+                    // Toast failure is non-fatal
+                }
+                return `✗ Error creating branch: ${error.message || error}`;
+            }
+            // Notify via toast
+            try {
+                await client.tui.showToast({
+                    body: {
+                        title: `Branch: ${branchName}`,
+                        message: `Created and checked out`,
+                        variant: "success",
+                        duration: 4000,
+                    },
+                });
+            }
+            catch {
+                // Toast failure is non-fatal
+            }
+            return `✓ Created and switched to branch: ${branchName}
 
 You are now on branch '${branchName}'.
 Make your changes and commit when ready.`;
-    },
-});
+        },
+    });
+}
 export const status = tool({
     description: "Get current git branch status - branch name, uncommitted changes, and whether on protected branch",
     args: {},
     async execute(args, context) {
         // Check if we're in a git repository
         try {
-            await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
+            await git(context.worktree, "rev-parse", "--git-dir");
         }
         catch {
             return "✗ Not in a git repository";
@@ -64,7 +98,8 @@ export const status = tool({
         let aheadBehind = "";
         // Get current branch
         try {
-            currentBranch = (await Bun.$ `git branch --show-current`.cwd(context.worktree).text()).trim();
+            const { stdout } = await git(context.worktree, "branch", "--show-current");
+            currentBranch = stdout.trim();
             if (!currentBranch) {
                 currentBranch = "(detached HEAD)";
             }
@@ -76,17 +111,17 @@ export const status = tool({
         isProtected = PROTECTED_BRANCHES.includes(currentBranch);
         // Check for changes
         try {
-            const statusOutput = await Bun.$ `git status --porcelain`.cwd(context.worktree).text();
-            const lines = statusOutput.trim().split("\n").filter((l) => l);
+            const { stdout } = await git(context.worktree, "status", "--porcelain");
+            const lines = stdout.trim().split("\n").filter((l) => l);
             for (const line of lines) {
-                const status = line.substring(0, 2);
-                if (status[0] !== " " && status[0] !== "?") {
+                const st = line.substring(0, 2);
+                if (st[0] !== " " && st[0] !== "?") {
                     stagedChanges = true;
                 }
-                if (status[1] !== " " && status[1] !== "?") {
+                if (st[1] !== " " && st[1] !== "?") {
                     hasChanges = true;
                 }
-                if (status === "??") {
+                if (st === "??") {
                     untrackedFiles = true;
                 }
             }
@@ -96,8 +131,8 @@ export const status = tool({
         }
         // Check ahead/behind
         try {
-            const result = await Bun.$ `git rev-list --left-right --count HEAD...@{upstream}`.cwd(context.worktree).text();
-            const [ahead, behind] = result.trim().split(/\s+/);
+            const { stdout } = await git(context.worktree, "rev-list", "--left-right", "--count", "HEAD...@{upstream}");
+            const [ahead, behind] = stdout.trim().split(/\s+/);
             if (parseInt(ahead) > 0 || parseInt(behind) > 0) {
                 aheadBehind = `Ahead: ${ahead}, Behind: ${behind}`;
             }
@@ -146,10 +181,10 @@ export const switch_ = tool({
         const { branch } = args;
         // Check if branch exists
         try {
-            const branches = await Bun.$ `git branch --list ${branch}`.cwd(context.worktree).text();
-            if (!branches.trim()) {
+            const { stdout } = await git(context.worktree, "branch", "--list", branch);
+            if (!stdout.trim()) {
                 // Try remote branch
-                const remoteBranches = await Bun.$ `git branch -r --list origin/${branch}`.cwd(context.worktree).text();
+                const { stdout: remoteBranches } = await git(context.worktree, "branch", "-r", "--list", `origin/${branch}`);
                 if (!remoteBranches.trim()) {
                     return `✗ Error: Branch '${branch}' not found locally or on origin.
 
@@ -162,7 +197,7 @@ Use branch_create to create a new branch.`;
         }
         // Switch to branch
         try {
-            await Bun.$ `git checkout ${branch}`.cwd(context.worktree);
+            await git(context.worktree, "checkout", branch);
         }
         catch (error) {
             return `✗ Error switching branch: ${error.message || error}

package/dist/tools/cortex.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export declare const init: {
     description: string;
     args: {};
@@ -8,4 +9,22 @@ export declare const status: {
     args: {};
     execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+/**
+ * cortex_configure — Write per-project model configuration to ./opencode.json.
+ *
+ * Accepts a primary model (for build/plan/debug) and a subagent model
+ * (for fullstack/testing/security/devops). Merges into any existing
+ * opencode.json at the project root, preserving other settings.
+ */
+export declare const configure: {
+    description: string;
+    args: {
+        primaryModel: z.ZodString;
+        subagentModel: z.ZodString;
+    };
+    execute(args: {
+        primaryModel: string;
+        subagentModel: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
 //# sourceMappingURL=cortex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cortex.d.ts","sourceRoot":"","sources":["../../src/tools/cortex.ts"],"names":[],"mappings":"AAkEA,eAAO,MAAM,IAAI;;;;CAkDf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAyDjB,CAAC"}
+{"version":3,"file":"cortex.d.ts","sourceRoot":"","sources":["../../src/tools/cortex.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqExB,eAAO,MAAM,IAAI;;;;CAkDf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAyDjB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAkHpB,CAAC"}

package/dist/tools/cortex.js

@@ -1,6 +1,8 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
+import { z } from "zod";
+import { PRIMARY_AGENTS, SUBAGENTS, MODEL_REGISTRY, } from "../registry.js";
 const CORTEX_DIR = ".cortex";
 const DEFAULT_CONFIG = {
     version: "1.0.0",
@@ -146,3 +148,110 @@ Plans: ${planCount}`;
         return output;
     },
 });
+/**
+ * cortex_configure — Write per-project model configuration to ./opencode.json.
+ *
+ * Accepts a primary model (for build/plan/debug) and a subagent model
+ * (for fullstack/testing/security/devops). Merges into any existing
+ * opencode.json at the project root, preserving other settings.
+ */
+export const configure = tool({
+    description: "Save per-project model configuration to ./opencode.json. " +
+        "Sets the model for primary agents (build, plan, debug) and subagents (fullstack, testing, security, devops). " +
+        "Available models — Premium: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "premium")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ". Standard: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "standard")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ". Fast: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "fast")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ".",
+    args: {
+        primaryModel: z
+            .string()
+            .describe("Model ID for primary agents (build, plan, debug). Format: provider/model-name"),
+        subagentModel: z
+            .string()
+            .describe("Model ID for subagents (fullstack, testing, security, devops). Format: provider/model-name"),
+    },
+    async execute(args, context) {
+        const configPath = path.join(context.worktree, "opencode.json");
+        // Read existing config or start fresh
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                // Malformed JSON — start fresh but warn
+                config = {};
+            }
+        }
+        // Ensure schema and plugin
+        if (!config.$schema) {
+            config.$schema = "https://opencode.ai/config.json";
+        }
+        const plugins = config.plugin ?? [];
+        if (!plugins.includes("cortex-agents")) {
+            plugins.push("cortex-agents");
+        }
+        config.plugin = plugins;
+        // Build agent config
+        const agent = config.agent ?? {};
+        for (const name of PRIMARY_AGENTS) {
+            if (!agent[name])
+                agent[name] = {};
+            agent[name].model = args.primaryModel;
+        }
+        for (const name of SUBAGENTS) {
+            if (!agent[name])
+                agent[name] = {};
+            agent[name].model = args.subagentModel;
+        }
+        config.agent = agent;
+        // Write to project root (runtime config — what OpenCode reads)
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        // Also write .opencode/models.json (per-project source of truth, version controlled)
+        const modelsPath = path.join(context.worktree, ".opencode", "models.json");
+        const modelsDir = path.dirname(modelsPath);
+        if (fs.existsSync(modelsDir)) {
+            const modelsConfig = {
+                primary: { model: args.primaryModel },
+                subagent: { model: args.subagentModel },
+                agents: {},
+            };
+            const agentsMap = {};
+            for (const name of PRIMARY_AGENTS) {
+                agentsMap[name] = { model: args.primaryModel };
+            }
+            for (const name of SUBAGENTS) {
+                agentsMap[name] = { model: args.subagentModel };
+            }
+            modelsConfig.agents = agentsMap;
+            fs.writeFileSync(modelsPath, JSON.stringify(modelsConfig, null, 2) + "\n");
+        }
+        // Build summary
+        const primaryDisplay = MODEL_REGISTRY.find((m) => m.id === args.primaryModel)?.name ??
+            args.primaryModel;
+        const subagentDisplay = MODEL_REGISTRY.find((m) => m.id === args.subagentModel)?.name ??
+            args.subagentModel;
+        const savedTo = fs.existsSync(modelsDir)
+            ? `${configPath}\n  .opencode/models.json`
+            : configPath;
+        return `✓ Model configuration saved to:
+  ${savedTo}
+
+Primary agents (build, plan, debug):
+  → ${primaryDisplay} (${args.primaryModel})
+
+Subagents (fullstack, testing, security, devops):
+  → ${subagentDisplay} (${args.subagentModel})
+
+Restart OpenCode to apply changes.`;
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/tools/session.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAsFf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CA8Df,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAuBf,CAAC"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/tools/session.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAuFf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CA8Df,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAuBf,CAAC"}

package/dist/tools/session.js

@@ -1,6 +1,7 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
+import { git } from "../utils/shell.js";
 const CORTEX_DIR = ".cortex";
 const SESSIONS_DIR = "sessions";
 function getDatePrefix() {
@@ -51,7 +52,8 @@ export const save = tool({
         let currentBranch = branch;
         if (!currentBranch) {
             try {
-                currentBranch = (await Bun.$ `git branch --show-current`.cwd(context.worktree).text()).trim();
+                const { stdout } = await git(context.worktree, "branch", "--show-current");
+                currentBranch = stdout.trim();
             }
             catch {
                 currentBranch = "unknown";

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;;;;;;;;;;;;;;;;;;CA0OnB,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AAyGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;CAqNnB,CAAC"}