commandmate 0.27.0 → 0.28.0

package/dist/server/src/lib/cli-tools/start-availability.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * The one place a start failure is reported, and the one place a start is
+ * refused because the binary is missing (Issue #2009 / #2022).
+ *
+ * ## Why this module exists at all
+ *
+ * #2009 established the rule: a CLI that cannot start must be refused by the
+ * tool itself, and that refusal must reach a phone through exactly one窓口 —
+ * `push/failure-push-notifier`. It wired the call inside
+ * `BaseCLITool.startSession`, which is correct for every caller that starts a
+ * tmux session.
+ *
+ * Assistant Chat is not one of them. Measured on this tree (see the docblock on
+ * `POST /api/assistant/start`), that route's `cliTool.startSession()` call is
+ * unreachable: the route 400s every interactive tool up front, so the
+ * non-interactive branch above it always returns first. Assistant Chat runs
+ * `claude -p` as a plain child process instead — `lib/assistant/
+ * non-interactive-runner` — so #2009's seam is not on its path and never was.
+ *
+ * Rather than give Assistant Chat a second, private call into the notifier, the
+ * reporting half moved here and `BaseCLITool.startSession` now calls it. There
+ * is still exactly one line in the repository that calls
+ * `notifySessionStartFailurePush`, and it is {@link reportSessionStartFailure};
+ * the difference is that a caller which does not create a tmux session can now
+ * reach it too.
+ *
+ * @module lib/cli-tools/start-availability
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportSessionStartFailure = reportSessionStartFailure;
+exports.assertToolStartable = assertToolStartable;
+exports.reportToolUnavailable = reportToolUnavailable;
+const session_start_error_1 = require("../session/session-start-error");
+/**
+ * Report a session-start failure. Fire-and-forget; never throws.
+ *
+ * Not awaited, for the reason `BaseCLITool.startSession` gave when this lived
+ * inside it: web push fans out to every registered device, and holding a 503
+ * open for that would make a failed start slower to report than a successful
+ * one. `notifySessionStartFailurePush` contains its own failures, and the
+ * `.catch` here is the belt for the import itself.
+ *
+ * `await import()` rather than a static import, for the reason Issue #1984
+ * gives on `CLIToolManager.stopPollers`: `push/failure-push-notifier` pulls the
+ * database and `web-push` behind it, and every one of the seven tool modules
+ * loads `./base`, which loads this file. Deferring it to the failure path keeps
+ * the cli-tools graph the size #1984 cut it down to.
+ *
+ * @param report - Who failed, and how the notification should be addressed
+ * @param error - Exactly what was thrown; the notifier classifies it
+ */
+function reportSessionStartFailure(report, error) {
+    void Promise.resolve().then(() => __importStar(require('../push/failure-push-notifier'))).then(({ notifySessionStartFailurePush }) => notifySessionStartFailurePush({ ...report, error }))
+        .catch(() => { });
+}
+/**
+ * Refuse a start this tool cannot perform, reporting it exactly as a failed
+ * launch does (Issue #2022).
+ *
+ * For a caller that goes on to `startSession()` this would be redundant — the
+ * tool's own `launchSession` already asks the same question, which is the
+ * duplicate #2009 removed from `POST /api/worktrees/:id/send`. It exists for
+ * the caller that never reaches `launchSession` at all: Assistant Chat spawns
+ * `claude -p` directly, so *something* has to answer "can this even run" before
+ * the route reports `status: 'ready'`, and the honest place for that answer is
+ * the tool object rather than a hand-rolled check at the HTTP layer.
+ *
+ * The wording is {@link SessionStartUnavailableError}'s class default — the
+ * sentence that error was built to replace the HTTP layer's copy with. A tool
+ * whose launch path has something more useful to say (copilot ships an install
+ * hint) still says it there; this function is reached only by callers that never
+ * get that far.
+ *
+ * @param tool - The tool being asked to start
+ * @param target - Who the refusal belongs to, and how to address it
+ * @throws SessionStartUnavailableError when the binary is not available
+ */
+async function assertToolStartable(tool, target) {
+    if (await tool.isInstalled())
+        return;
+    const error = new session_start_error_1.SessionStartUnavailableError(tool.name);
+    reportSessionStartFailure({
+        worktreeId: target.worktreeId,
+        cliToolId: tool.id,
+        instanceId: target.instanceId,
+        toolName: tool.name,
+        subject: target.subject,
+    }, error);
+    throw error;
+}
+/**
+ * Report a CLI that could not be exec'd, for a caller holding an id and no tool
+ * object (Issue #2022).
+ *
+ * The name has to come from `ICLITool.name` — "Claude Code", not the short UI
+ * label `CLI_TOOL_DISPLAY_NAMES` carries ("Claude"). Both are legitimate
+ * spellings and the repository uses each in its own place, but ONE missing
+ * binary must not read differently depending on which of the two paths found
+ * it, and the start gate above reads the tool object. So this one does too.
+ *
+ * `await import('./manager')` because a static import would be a module-scope
+ * cycle: the manager constructs all seven tools, every one of them extends
+ * `./base`, and `./base` imports this file. Deferred, there is no cycle and no
+ * cost — by the time an assistant execution fails, the route that started it has
+ * already loaded the manager.
+ *
+ * Fire-and-forget and swallowing its own faults, like {@link
+ * reportSessionStartFailure}: a phone that cannot be reached must never change
+ * what the caller does next.
+ *
+ * @param cliToolId - The tool whose binary is missing
+ * @param target - Who the failure belongs to, and how to address it
+ */
+function reportToolUnavailable(cliToolId, target) {
+    void Promise.resolve().then(() => __importStar(require('./manager'))).then(({ CLIToolManager }) => {
+        const toolName = CLIToolManager.getInstance().getTool(cliToolId).name;
+        reportSessionStartFailure({
+            worktreeId: target.worktreeId,
+            cliToolId,
+            instanceId: target.instanceId,
+            toolName,
+            subject: target.subject,
+        }, new session_start_error_1.SessionStartUnavailableError(toolName));
+    })
+        .catch(() => { });
+}

package/dist/server/src/lib/cmate-cli-tool-parser.js

@@ -10,17 +10,26 @@
  * - parseCliToolColumn(): tokenize raw CLI Tool column string
  * - validateCopilotModelName(): validate model name (reject approach)
  * - validateAntigravityModelName(): validate Antigravity --model value (Issue #989)
+ * - validateOpencodeRunName(): validate --agent / --variant values (Issue #2044)
+ * - validateOpencodeTitle(): validate --title value (Issue #2044)
  * - parseAndValidateCliToolColumn(): combined pipeline entry point
+ * - resolveScheduleCommandOptions(): CMATE.md row -> executor options (Issue #2044)
  * - TOOLS_WITH_MODEL_SUPPORT: Set of tools supporting --model in CMATE.md
+ * - TOOLS_WITH_RUN_OPTIONS: Set of tools whose column accepts a flag list
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOLS_WITH_MODEL_SUPPORT = void 0;
+exports.OPENCODE_COLUMN_SYNTAX = exports.TOOLS_WITH_RUN_OPTIONS = exports.TOOLS_WITH_MODEL_SUPPORT = void 0;
+exports.tokenizeCliToolColumn = tokenizeCliToolColumn;
 exports.parseCliToolColumn = parseCliToolColumn;
 exports.validateCopilotModelName = validateCopilotModelName;
 exports.validateAntigravityModelName = validateAntigravityModelName;
+exports.validateOpencodeRunName = validateOpencodeRunName;
+exports.validateOpencodeTitle = validateOpencodeTitle;
 exports.parseAndValidateCliToolColumn = parseAndValidateCliToolColumn;
+exports.resolveScheduleCommandOptions = resolveScheduleCommandOptions;
 const copilot_constants_1 = require("../config/copilot-constants");
 const antigravity_constants_1 = require("../config/antigravity-constants");
+const opencode_constants_1 = require("../config/opencode-constants");
 // =============================================================================
 // Constants
 // =============================================================================
@@ -34,12 +43,13 @@ const antigravity_constants_1 = require("../config/antigravity-constants");
  *
  * `claude-executor.ts` has carried an `opencode run -m <model>` branch since
  * Issue #379, and it had never once executed: the only caller that supplies a
- * model for a schedule is `job-executor.resolveModelOption()`, which answered
+ * model for a schedule is job-executor's option resolver, which answered
  * `undefined` for every tool but copilot and vibe-local, and the other reachable
  * caller (`daily-summary-generator`) is gated by `SUMMARY_ALLOWED_TOOLS`, which
  * has no opencode either. Adding the id here is one half of making that branch
- * reachable; `resolveModelOption()` reads this Set for the other half, so the
- * two cannot drift apart again.
+ * reachable; the resolver reads this Set for the other half (through
+ * {@link resolveScheduleCommandOptions} since #2044), so the two cannot drift
+ * apart again.
  *
  * The value is passed through **verbatim** as `provider/model`, which is the
  * format `opencode run --help` documents for `-m, --model` (measured on
@@ -47,11 +57,173 @@ const antigravity_constants_1 = require("../config/antigravity-constants");
  * `buildCliArgs()` for why that prefix went away.
  */
 exports.TOOLS_WITH_MODEL_SUPPORT = new Set(['copilot', 'opencode']);
+/**
+ * CLI Tools whose CMATE.md column is a **flag list** rather than one fixed shape
+ * (Issue #2044).
+ *
+ * Every other tool in {@link TOOLS_WITH_MODEL_SUPPORT} accepts exactly
+ * `<tool> --model <name>` and nothing else, and that stayed true here on
+ * purpose: widening copilot's grammar is a behaviour change nobody asked for,
+ * and the narrow rule is what makes `copilot --modle x` an error instead of a
+ * silently ignored token.
+ *
+ * `opencode` is the exception because `opencode run` has four more options
+ * CommandMate can drive (`--agent`, `--variant`, `-c`, `--title`), and a
+ * schedule that wants `--agent plan --variant high` cannot say so in three
+ * tokens. Membership here is what {@link parseCliToolColumn} branches on.
+ */
+exports.TOOLS_WITH_RUN_OPTIONS = new Set(['opencode']);
+/**
+ * The opencode column grammar, as one line, for error messages.
+ *
+ * Kept next to the parser rather than inlined so the message a user sees and
+ * the flags the loop accepts are edited together.
+ */
+exports.OPENCODE_COLUMN_SYNTAX = 'opencode [--model <provider/model>] [--agent <name>] [--variant <name>] [--continue] [--title <text>]';
 // =============================================================================
 // Parse Functions
 // =============================================================================
 /**
- * Parse a raw CLI Tool column string into cliToolId and optional model.
+ * Split a CLI Tool column value into argv-like tokens (Issue #2044).
+ *
+ * Whitespace-separated, except that `"…"` and `'…'` keep their contents
+ * together. Quoting exists for exactly one option — `--title`, whose value is
+ * prose ("nightly review") rather than an identifier. Without it the only
+ * titles expressible in a Markdown cell would be single words, which is the
+ * kind of limitation that gets discovered after someone has written the row.
+ *
+ * The quote characters are removed, so `--title "nightly review"` yields the
+ * token `nightly review`. An unterminated quote is an error rather than an
+ * implicit close: silently accepting `--title "nightly` would write a schedule
+ * whose title is not the one that was typed.
+ *
+ * @param raw - Trimmed CLI Tool column value
+ * @returns The tokens, or an error describing the quoting fault
+ */
+function tokenizeCliToolColumn(raw) {
+    const tokens = [];
+    let current = '';
+    let started = false;
+    let quote = null;
+    for (const char of raw) {
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (started) {
+                tokens.push(current);
+                current = '';
+                started = false;
+            }
+            continue;
+        }
+        current += char;
+        started = true;
+    }
+    if (quote) {
+        return { tokens: [], error: 'CLI Tool column has an unterminated quote' };
+    }
+    if (started)
+        tokens.push(current);
+    return { tokens };
+}
+/**
+ * Parse the opencode flag list that follows the tool id (Issue #2044).
+ *
+ * Reads `[--model|-m <v>] [--agent <v>] [--variant <v>] [--continue|-c]
+ * [--title <v>]` in any order. Three things are refused rather than tolerated,
+ * each because tolerating it would produce a schedule that runs differently
+ * from what the row says:
+ *
+ * - **an unknown flag** — `--agnet plan` would otherwise run the default agent;
+ * - **a repeated flag** — the CLI would take one of the two values and there is
+ *   no reading of the row that says which;
+ * - **a missing value** — `--agent --title x` would make `--title` the agent
+ *   name, and a value starting with `-` is the DR4-001 injection shape anyway.
+ *
+ * @param cliToolId - Always `opencode` today; echoed into error messages
+ * @param tokens - Tokens after the tool id
+ * @returns The parsed options, or an error
+ */
+function parseOpencodeRunFlags(cliToolId, tokens) {
+    const parsed = { cliToolId };
+    const seen = new Set();
+    const takeValue = (flag, index) => {
+        const value = tokens[index + 1];
+        if (value === undefined || value.startsWith('-'))
+            return null;
+        return value;
+    };
+    for (let i = 0; i < tokens.length; i++) {
+        const flag = tokens[i];
+        if (seen.has(flag)) {
+            return { cliToolId, error: `${cliToolId} option "${flag}" is repeated` };
+        }
+        switch (flag) {
+            case '--model':
+            case '-m': {
+                const value = takeValue(flag, i);
+                if (value === null)
+                    return { cliToolId, error: `${cliToolId} option "${flag}" needs a value` };
+                seen.add('--model');
+                seen.add('-m');
+                parsed.model = value;
+                i++;
+                break;
+            }
+            case '--agent': {
+                const value = takeValue(flag, i);
+                if (value === null)
+                    return { cliToolId, error: `${cliToolId} option "${flag}" needs a value` };
+                seen.add(flag);
+                parsed.agent = value;
+                i++;
+                break;
+            }
+            case '--variant': {
+                const value = takeValue(flag, i);
+                if (value === null)
+                    return { cliToolId, error: `${cliToolId} option "${flag}" needs a value` };
+                seen.add(flag);
+                parsed.variant = value;
+                i++;
+                break;
+            }
+            case '--title': {
+                const value = takeValue(flag, i);
+                if (value === null)
+                    return { cliToolId, error: `${cliToolId} option "${flag}" needs a value` };
+                seen.add(flag);
+                parsed.title = value;
+                i++;
+                break;
+            }
+            case '--continue':
+            case '-c': {
+                seen.add('--continue');
+                seen.add('-c');
+                parsed.continueSession = true;
+                break;
+            }
+            default:
+                return { cliToolId, error: `${cliToolId} only supports: ${exports.OPENCODE_COLUMN_SYNTAX}` };
+        }
+    }
+    return parsed;
+}
+/**
+ * Parse a raw CLI Tool column string into cliToolId and optional run options.
  * Syntax errors are reported via the error field (DR1-002).
  *
  * Examples:
@@ -59,9 +231,13 @@ exports.TOOLS_WITH_MODEL_SUPPORT = new Set(['copilot', 'opencode']);
  * - "claude" -> { cliToolId: "claude", model: undefined }
  * - "" / "  " -> { cliToolId: "claude", model: undefined } (default)
  * - "claude --model x" -> { cliToolId: "claude", error: "..." }
+ * - "opencode --agent plan --variant high"
+ *     -> { cliToolId: "opencode", agent: "plan", variant: "high" }   (Issue #2044)
  *
  * Security (DR4-002): Error messages use fixed text + allowed syntax hints,
- * not raw input values, to prevent log injection / UI toast pollution.
+ * not raw input values, to prevent log injection / UI toast pollution. The one
+ * value echoed back is the offending **flag**, which had to match one of the
+ * literals above or is reported as the generic syntax hint.
  *
  * @param raw - Raw CLI Tool column value from CMATE.md table
  * @returns Parsed result with optional error
@@ -71,7 +247,12 @@ function parseCliToolColumn(raw) {
     if (!trimmed) {
         return { cliToolId: 'claude', model: undefined };
     }
-    const tokens = trimmed.split(/\s+/);
+    const { tokens, error: tokenizeError } = tokenizeCliToolColumn(trimmed);
+    if (tokenizeError) {
+        // The tool id is unknown when quoting failed; report the column's default so
+        // the caller still has a usable cliToolId to name in its own message.
+        return { cliToolId: trimmed.split(/\s+/)[0], error: tokenizeError };
+    }
     const cliToolId = tokens[0];
     if (tokens.length === 1) {
         return { cliToolId, model: undefined };
@@ -80,6 +261,11 @@ function parseCliToolColumn(raw) {
     if (!exports.TOOLS_WITH_MODEL_SUPPORT.has(cliToolId)) {
         return { cliToolId, error: `CLI Tool "${cliToolId}" does not support additional options` };
     }
+    // Issue #2044: opencode's column is a flag list; every other tool keeps the
+    // exactly-three-tokens rule it has had since #588.
+    if (exports.TOOLS_WITH_RUN_OPTIONS.has(cliToolId)) {
+        return parseOpencodeRunFlags(cliToolId, tokens.slice(1));
+    }
     // Only accept: <tool> --model <name> (exactly 3 tokens)
     if (tokens.length === 3 && tokens[1] === '--model') {
         return { cliToolId, model: tokens[2] };
@@ -156,6 +342,77 @@ function validateAntigravityModelName(modelName) {
     }
     return { valid: true };
 }
+/**
+ * Validate an opencode `--agent` / `--variant` value (Issue #2044).
+ *
+ * Reject, never sanitize — the same stance as the two validators above, for the
+ * same reason: this value becomes an argv element, and a "cleaned" agent name
+ * runs a *different* agent than the row asked for, silently.
+ *
+ * What is deliberately **not** checked is membership in a list of known agents
+ * or variants. opencode lets a project declare its own agents in
+ * `opencode.json`, and the variant vocabulary is provider-specific
+ * (`opencode run --help` on 1.18.22 calls it "provider-specific reasoning
+ * effort, e.g., high, max, minimal" — an *example* list, not an enum). A
+ * whitelist here would reject valid configurations this layer cannot see.
+ *
+ * @param value - The `--agent` or `--variant` value
+ * @param label - Which option is being validated, for the message
+ * @returns Validation result with optional reason for rejection
+ */
+function validateOpencodeRunName(value, label) {
+    if (/[\x00-\x1f\x7f]/.test(value)) {
+        return { valid: false, reason: `opencode ${label} contains control characters` };
+    }
+    if (value.trim() === '') {
+        return { valid: false, reason: `opencode ${label} must not be empty` };
+    }
+    if (!opencode_constants_1.OPENCODE_RUN_NAME_PATTERN.test(value)) {
+        return { valid: false, reason: `opencode ${label} contains invalid characters` };
+    }
+    if (value.length > opencode_constants_1.MAX_OPENCODE_RUN_NAME_LENGTH) {
+        return {
+            valid: false,
+            reason: `opencode ${label} exceeds ${opencode_constants_1.MAX_OPENCODE_RUN_NAME_LENGTH} characters`,
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate an opencode `--title` value (Issue #2044).
+ *
+ * Looser than {@link validateOpencodeRunName} because a title is prose: spaces
+ * and non-ASCII are the point of the option. Three bounds remain:
+ *
+ * - **no control characters**, the log-injection rule every other value here
+ *   follows;
+ * - **no leading `-`**, so a title cannot be read by the CLI as another option
+ *   (DR4-001);
+ * - **no `|`**, because the value round-trips through a Markdown table cell.
+ *   `cmate-writer.escapeTableCell()` would rewrite it to `｜` on write, so
+ *   accepting it here would mean the title stored is not the title given.
+ *
+ * @param title - The `--title` value
+ * @returns Validation result with optional reason for rejection
+ */
+function validateOpencodeTitle(title) {
+    if (/[\x00-\x1f\x7f]/.test(title)) {
+        return { valid: false, reason: 'opencode title contains control characters' };
+    }
+    if (title.trim() === '') {
+        return { valid: false, reason: 'opencode title must not be empty' };
+    }
+    if (title.startsWith('-')) {
+        return { valid: false, reason: 'opencode title must not start with "-"' };
+    }
+    if (title.includes('|')) {
+        return { valid: false, reason: 'opencode title must not contain "|"' };
+    }
+    if (title.length > opencode_constants_1.MAX_OPENCODE_TITLE_LENGTH) {
+        return { valid: false, reason: `opencode title exceeds ${opencode_constants_1.MAX_OPENCODE_TITLE_LENGTH} characters` };
+    }
+    return { valid: true };
+}
 // =============================================================================
 // Combined Pipeline
 // =============================================================================
@@ -187,5 +444,69 @@ function parseAndValidateCliToolColumn(raw) {
             errors.push(modelResult.reason);
         }
     }
+    // Issue #2044: opencode's run options. Only reachable when the parser filled
+    // them, which it does only for ids in TOOLS_WITH_RUN_OPTIONS.
+    if (parsed.agent) {
+        const agentResult = validateOpencodeRunName(parsed.agent, 'agent');
+        if (!agentResult.valid)
+            errors.push(agentResult.reason);
+    }
+    if (parsed.variant) {
+        const variantResult = validateOpencodeRunName(parsed.variant, 'variant');
+        if (!variantResult.valid)
+            errors.push(variantResult.reason);
+    }
+    if (parsed.title) {
+        const titleResult = validateOpencodeTitle(parsed.title);
+        if (!titleResult.valid)
+            errors.push(titleResult.reason);
+    }
     return { result: parsed, errors };
 }
+// =============================================================================
+// Schedule -> Executor Options (Issue #2044)
+// =============================================================================
+/**
+ * Turn a parsed CMATE.md row into the options `executeClaudeCommand()` takes.
+ *
+ * This is what `job-executor.resolveScheduleExecuteOptions()` delegates the
+ * CMATE.md half of its job to, and it replaced an inlined
+ * `if (entry.model && TOOLS_WITH_MODEL_SUPPORT.has(…)) return { model }` at that
+ * call site — a shape that can express exactly one option and therefore dropped
+ * `--agent` / `--variant` / `-c` / `--title` on the floor. It reads
+ * {@link TOOLS_WITH_MODEL_SUPPORT} for the model, exactly as that line did, so
+ * the two agree about which tools take one; the run options are additionally
+ * gated on {@link TOOLS_WITH_RUN_OPTIONS} so a future tool cannot inherit
+ * opencode's flags by accident.
+ *
+ * Living here rather than in `job-executor.ts` is the point: the column's
+ * grammar is this module's business, and a scheduler that re-states any part of
+ * it is a second copy that will drift — which is precisely what #1914 found
+ * (`cliToolId === 'copilot'` hard-coded next to the parser's Set) and what
+ * #2044 found one field later.
+ *
+ * `vibe-local` is deliberately absent: its model lives in the worktree row
+ * rather than in CMATE.md, so `resolveScheduleExecuteOptions()` keeps that
+ * branch and this function answers `undefined` for it.
+ *
+ * @param entry - Parsed schedule entry from CMATE.md
+ * @returns Options to pass to `executeClaudeCommand`, or undefined when the row
+ *   asks for nothing beyond the tool's defaults
+ */
+function resolveScheduleCommandOptions(entry) {
+    const options = {};
+    if (entry.model && exports.TOOLS_WITH_MODEL_SUPPORT.has(entry.cliToolId)) {
+        options.model = entry.model;
+    }
+    if (exports.TOOLS_WITH_RUN_OPTIONS.has(entry.cliToolId)) {
+        if (entry.agent)
+            options.agent = entry.agent;
+        if (entry.variant)
+            options.variant = entry.variant;
+        if (entry.continueSession)
+            options.continueSession = true;
+        if (entry.title)
+            options.title = entry.title;
+    }
+    return Object.keys(options).length > 0 ? options : undefined;
+}

package/dist/server/src/lib/cmate-parser.js

@@ -152,6 +152,9 @@ function parseCmateFile(content) {
  * |------|------|---------|----------|---------|
  * | daily-review | 0 9 * * * | Review code changes | claude | true |
  *
+ * Issue #2044: the CLI Tool cell may carry opencode's run options, e.g.
+ * `opencode --agent plan --variant high`. See `cmate-cli-tool-parser.ts`.
+ *
  * Entries with invalid names, cron expressions, or missing required fields
  * are silently skipped with a console.warn.
  *
@@ -250,7 +253,16 @@ function parseSchedulesSection(rows) {
             cliToolId: resolvedCliToolId,
             enabled,
             permission,
+            // Issue #2044: the opencode run options ride alongside the model. The
+            // parser copies whatever `parseAndValidateCliToolColumn()` filled and
+            // does not re-gate on the tool id — that gate lives in the column parser
+            // (TOOLS_WITH_RUN_OPTIONS), and duplicating it here is how the copilot
+            // model gate ended up in two places and drifted (#1914).
             model: parsed.model,
+            agent: parsed.agent,
+            variant: parsed.variant,
+            continueSession: parsed.continueSession,
+            title: parsed.title,
         });
     }
     return entries;