@bridge_gpt/mcp-server 0.2.2 → 0.2.4

package/build/review-tickets.js

@@ -0,0 +1,596 @@
+/**
+ * review-tickets — packaged CLI subcommand of the bridge-api-mcp-server bin.
+ *
+ * Reuses the `start-tickets` terminal spawn layer directly, running reviews in
+ * the current `deps.cwd`. Intentionally does NOT create Worktrunk worktrees,
+ * provision MCP registrations, run venv hooks, or perform difficulty/model-tier
+ * routing. One terminal tab per ticket is spawned with `/review-ticket <KEY>
+ * [--auto] --rounds=<1|2>` as the agent prompt.
+ *
+ * Optionally supports a supervisor-driven epic-dispatch path: when an
+ * `EpicDispatchIdentity` is threaded through `ReviewTicketsOptions.epic`, each
+ * spawned tab receives an epic-identity env block (BAPI_CONDUCTOR_EPIC_KEY /
+ * BAPI_CONDUCTOR_EPIC_RUN_ID / BAPI_CONDUCTOR_PLAN_VERSION / BAPI_CONDUCTOR_RUN_ID)
+ * and dispatch is made idempotent via an injected `claimEpicDispatch` callback.
+ * This path is worktree-free and base-branch-free; the human CLI path leaves
+ * `epic` unset and retains byte-for-byte identical behavior.
+ */
+import { createDefaultStartTicketsDeps, detectTerminal, runWithConcurrency, buildAgentInvocation, shSquoteInner, powershellSquote, isCommandOnPath, resolveFirstCommandOnPath, tmuxSessionNameForTicket, TICKET_KEY_PATTERN, DEFAULT_MAX_PARALLEL, } from "./start-tickets.js";
+import { WINDOWS_TERMINAL_COMMAND, WINDOWS_POWERSHELL_CANDIDATES, TMUX_COMMAND, isSupportedStartTicketsPlatform, unsupportedPlatformMessage, } from "./start-tickets-prereqs.js";
+import { DEFAULT_AGENT_NAME, resolveAgentSpec, isAgentName, formatValidAgentNames, isValidModelAlias, } from "./agent-registry.js";
+import { injectConductorEnvIntoShellCommand, buildEpicIdentityEnv, mintStartTicketsRunId, } from "./start-tickets-conductor.js";
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+export function getReviewTicketsUsage() {
+    return [
+        "Usage:",
+        "  npx -y @bridge_gpt/mcp-server review-tickets [flags] KEY [KEY ...]",
+        "",
+        "Flags:",
+        "  --auto                            Auto-approve all review gates (global, applies to all tickets)",
+        "  --rounds=1|2                      Review depth: 1=single-pass, 2=full two-pass (default: 2)",
+        "  --review KEY=auto,rounds=1        Per-ticket review mode override (repeatable)",
+        "  --agent claude|cursor-agent       Agent command to launch in each tab (default: claude)",
+        "  --model VALUE                     Model alias to pass as --model to the agent (optional passthrough)",
+        "  --max-parallel N                  Max tabs to spawn concurrently (default: 3)",
+        "  --dry-run                         Print intended commands; creates no tabs and opens no sessions",
+        "  -h, --help                        Show this help",
+        "",
+        "Examples:",
+        "  npx -y @bridge_gpt/mcp-server review-tickets BAPI-1 BAPI-2",
+        "  npx -y @bridge_gpt/mcp-server review-tickets --auto --rounds=1 BAPI-1 BAPI-2",
+        "  npx -y @bridge_gpt/mcp-server review-tickets --review BAPI-1=auto,rounds=1 --review BAPI-2=rounds=2 BAPI-1 BAPI-2",
+        "  npx -y @bridge_gpt/mcp-server review-tickets --dry-run BAPI-1 BAPI-2",
+        "",
+        "Each KEY must match [A-Z]+-[0-9]+ (e.g., BAPI-248).",
+        "",
+        "Prerequisites (terminal launcher only — no wt, git-wt, git, or Worktrunk required):",
+        "  macOS    osascript",
+        "  Windows  wt.exe or PowerShell",
+        "  Linux    tmux",
+        "",
+        "review-tickets runs all tabs in the current repository cwd and creates no Worktrunk worktrees.",
+        "--dry-run works on any platform, including unsupported ones.",
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+export function parseReviewOverrideEntry(entry, requestedKeys) {
+    const eqIdx = entry.indexOf("=");
+    if (eqIdx <= 0) {
+        return { ok: false, error: `Invalid --review value: '${entry}' (expected KEY=auto,rounds=1 or KEY=rounds=2).` };
+    }
+    const key = entry.slice(0, eqIdx);
+    const rest = entry.slice(eqIdx + 1);
+    if (!TICKET_KEY_PATTERN.test(key)) {
+        return { ok: false, error: `Invalid --review override key: '${key}' (keys must match [A-Z]+-[0-9]+).` };
+    }
+    if (!requestedKeys.has(key)) {
+        return { ok: false, error: `--review override key '${key}' is not one of the requested tickets.` };
+    }
+    const subtokens = rest.split(",");
+    const override = {};
+    for (const token of subtokens) {
+        if (token.trim() === "") {
+            return { ok: false, error: `Invalid --review value for '${key}': empty subtoken in '${rest}'.` };
+        }
+        if (token === "auto") {
+            override.auto = true;
+        }
+        else if (token.startsWith("rounds=")) {
+            const val = token.slice("rounds=".length);
+            if (val !== "1" && val !== "2") {
+                return {
+                    ok: false,
+                    error: `Invalid --review rounds for '${key}': '${val}' (must be 1 or 2).`,
+                };
+            }
+            override.rounds = Number(val);
+        }
+        else {
+            return { ok: false, error: `Invalid --review subtoken for '${key}': '${token}' (supported: auto, rounds=1, rounds=2).` };
+        }
+    }
+    return { ok: true, key, override };
+}
+export function parseReviewTicketsArgs(argv) {
+    if (argv.includes("-h") || argv.includes("--help")) {
+        return { status: "help", usage: getReviewTicketsUsage() };
+    }
+    let dryRun = false;
+    let globalAuto = false;
+    let globalRounds;
+    let maxParallelRaw;
+    let agentName = DEFAULT_AGENT_NAME;
+    let modelAlias;
+    const keys = [];
+    const rawReviewEntries = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const takeValue = () => {
+            if (i + 1 >= argv.length)
+                return undefined;
+            i += 1;
+            return argv[i];
+        };
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--auto") {
+            globalAuto = true;
+            continue;
+        }
+        if (arg === "--rounds" || arg.startsWith("--rounds=")) {
+            let value;
+            if (arg.startsWith("--rounds=")) {
+                value = arg.slice("--rounds=".length);
+            }
+            else {
+                value = takeValue();
+                if (value === undefined) {
+                    return { status: "error", message: "--rounds requires a value (1 or 2)." };
+                }
+            }
+            if (value !== "1" && value !== "2") {
+                return {
+                    status: "error",
+                    message: `Invalid --rounds value: '${value}' (must be 1 or 2).`,
+                };
+            }
+            globalRounds = Number(value);
+            continue;
+        }
+        if (arg === "--max-parallel" || arg.startsWith("--max-parallel=")) {
+            if (arg.startsWith("--max-parallel=")) {
+                maxParallelRaw = arg.slice("--max-parallel=".length);
+            }
+            else {
+                const value = takeValue();
+                if (value === undefined) {
+                    return { status: "error", message: "--max-parallel requires a positive integer value." };
+                }
+                maxParallelRaw = value;
+            }
+            continue;
+        }
+        if (arg === "--agent" || arg.startsWith("--agent=")) {
+            let value;
+            if (arg.startsWith("--agent=")) {
+                value = arg.slice("--agent=".length);
+            }
+            else {
+                value = takeValue();
+                if (value === undefined) {
+                    return { status: "error", message: "--agent requires a value (an agent name)." };
+                }
+            }
+            if (!isAgentName(value)) {
+                return {
+                    status: "error",
+                    message: `Invalid --agent value: '${value}' (allowed agents: ${formatValidAgentNames()}).`,
+                };
+            }
+            agentName = value;
+            continue;
+        }
+        if (arg === "--model" || arg.startsWith("--model=")) {
+            let value;
+            if (arg.startsWith("--model=")) {
+                value = arg.slice("--model=".length);
+            }
+            else {
+                value = takeValue();
+                if (value === undefined) {
+                    return { status: "error", message: "--model requires a value (a model alias)." };
+                }
+            }
+            if (!value || !isValidModelAlias(value)) {
+                return {
+                    status: "error",
+                    message: `Invalid --model value: '${value ?? ""}' (must match [A-Za-z0-9._:-]+).`,
+                };
+            }
+            modelAlias = value;
+            continue;
+        }
+        if (arg === "--review" || arg.startsWith("--review=")) {
+            let value;
+            if (arg.startsWith("--review=")) {
+                value = arg.slice("--review=".length);
+            }
+            else {
+                value = takeValue();
+                if (value === undefined) {
+                    return { status: "error", message: "--review requires a value (KEY=auto,rounds=1)." };
+                }
+            }
+            rawReviewEntries.push(value);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { status: "error", message: `Unknown flag: ${arg}` };
+        }
+        keys.push(arg);
+    }
+    // --- key validation ---
+    if (keys.length === 0) {
+        return {
+            status: "error",
+            message: "At least one ticket key is required (e.g., BAPI-248).",
+        };
+    }
+    const seen = new Set();
+    for (const key of keys) {
+        if (!TICKET_KEY_PATTERN.test(key)) {
+            return {
+                status: "error",
+                message: `Invalid ticket key: '${key}' (keys must match [A-Z]+-[0-9]+, e.g., BAPI-248).`,
+            };
+        }
+        if (seen.has(key)) {
+            return { status: "error", message: `Duplicate ticket key: '${key}'.` };
+        }
+        seen.add(key);
+    }
+    // --- max-parallel validation ---
+    let maxParallel = DEFAULT_MAX_PARALLEL;
+    if (maxParallelRaw !== undefined) {
+        if (!/^[0-9]+$/.test(maxParallelRaw) || Number(maxParallelRaw) < 1) {
+            return {
+                status: "error",
+                message: `Invalid --max-parallel value: '${maxParallelRaw}' (must be a positive integer).`,
+            };
+        }
+        maxParallel = Number(maxParallelRaw);
+    }
+    // --- review override validation (needs full key set) ---
+    const reviewOverrides = {};
+    for (const entry of rawReviewEntries) {
+        const result = parseReviewOverrideEntry(entry, seen);
+        if (!result.ok) {
+            return { status: "error", message: result.error };
+        }
+        // Merge: layer later parsed fields over earlier parsed fields
+        reviewOverrides[result.key] = { ...(reviewOverrides[result.key] ?? {}), ...result.override };
+    }
+    return {
+        status: "ok",
+        options: {
+            keys,
+            dryRun,
+            maxParallel,
+            agentName,
+            modelAlias,
+            auto: globalAuto,
+            rounds: globalRounds,
+            reviewOverrides,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Mode resolution
+// ---------------------------------------------------------------------------
+export function resolveEffectiveReviewMode(key, options) {
+    const override = options.reviewOverrides[key];
+    const auto = override?.auto !== undefined ? override.auto : options.auto;
+    const rounds = override?.rounds !== undefined
+        ? override.rounds
+        : options.rounds !== undefined
+            ? options.rounds
+            : 2;
+    return { auto, rounds };
+}
+// ---------------------------------------------------------------------------
+// Command builders
+// The existing start-tickets builders include a worktree `cd` prefix and are
+// hard-wired to `/implement-ticket`. Review-aware builders are used instead so
+// the prompt uses `/review-ticket` and no directory change is prepended.
+// ---------------------------------------------------------------------------
+export function buildReviewTicketPrompt(key, mode) {
+    const autoFlag = mode.auto ? " --auto" : "";
+    return `/review-ticket ${key}${autoFlag} --rounds=${mode.rounds}`;
+}
+export function buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias) {
+    const prompt = buildReviewTicketPrompt(key, mode);
+    const invocation = buildAgentInvocation(agent, prompt, (p) => `'${shSquoteInner(p)}'`, modelAlias);
+    return `cd '${shSquoteInner(cwd)}' && ${invocation}`;
+}
+export function buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias) {
+    const prompt = buildReviewTicketPrompt(key, mode);
+    return buildAgentInvocation(agent, prompt, powershellSquote, modelAlias);
+}
+export function buildReviewAgentShellCommand(agent, key, mode, platform, cwd, modelAlias) {
+    if (platform === "win32") {
+        return buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias);
+    }
+    return buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias);
+}
+// ---------------------------------------------------------------------------
+// Unsupported platform message for review-tickets
+// ---------------------------------------------------------------------------
+export function unsupportedReviewTicketsPlatformMessage(platform) {
+    const base = unsupportedPlatformMessage(platform);
+    // Replace "start-tickets" wording with "review-tickets"
+    return base.replace(/start-tickets/g, "review-tickets");
+}
+// ---------------------------------------------------------------------------
+// Preflight (launcher-only prerequisites — no Worktrunk/git/agent probes)
+// ---------------------------------------------------------------------------
+export async function runReviewTicketsPreflight(deps, options) {
+    if (options.dryRun)
+        return { ok: true };
+    if (!isSupportedStartTicketsPlatform(deps.platform)) {
+        return { ok: false, error: unsupportedReviewTicketsPlatformMessage(deps.platform) };
+    }
+    if (deps.platform === "darwin") {
+        if (await isCommandOnPath(deps, "osascript"))
+            return { ok: true };
+        return {
+            ok: false,
+            error: "osascript is required to open a macOS terminal tab for review-tickets but was not found on PATH.",
+        };
+    }
+    if (deps.platform === "win32") {
+        if (await isCommandOnPath(deps, WINDOWS_TERMINAL_COMMAND))
+            return { ok: true };
+        const powershell = await resolveFirstCommandOnPath(deps, WINDOWS_POWERSHELL_CANDIDATES);
+        if (powershell)
+            return { ok: true };
+        return {
+            ok: false,
+            error: "Windows Terminal (wt.exe) or PowerShell is required to open a review-tickets tab, but neither was found on PATH.",
+        };
+    }
+    // linux
+    if (await isCommandOnPath(deps, TMUX_COMMAND))
+        return { ok: true };
+    return {
+        ok: false,
+        error: "tmux is required to spawn Linux review-tickets sessions but was not found on PATH. Install tmux and retry.",
+    };
+}
+// ---------------------------------------------------------------------------
+// Plan rows + orchestration
+// ---------------------------------------------------------------------------
+export function buildReviewPlanRows(deps, options, agent, status, overrides = {}) {
+    return options.keys.map((key) => {
+        const mode = resolveEffectiveReviewMode(key, options);
+        const baseCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, options.modelAlias);
+        let command = baseCommand;
+        let runId;
+        if (options.epic) {
+            const mint = overrides.mintRunId ?? mintStartTicketsRunId;
+            runId = mint([key]);
+            const env = { ...buildEpicIdentityEnv(options.epic), BAPI_CONDUCTOR_RUN_ID: runId };
+            command = injectConductorEnvIntoShellCommand(deps.platform, baseCommand, env);
+        }
+        return {
+            key,
+            auto: mode.auto,
+            rounds: mode.rounds,
+            agentName: options.agentName,
+            modelAlias: options.modelAlias,
+            status,
+            command,
+            runId,
+        };
+    });
+}
+export async function orchestrateReviewTickets(deps, options, overrides = {}) {
+    const agent = resolveAgentSpec(options.agentName);
+    if (!agent) {
+        return {
+            ok: false,
+            error: `Unknown agent: '${options.agentName}'. Valid agents: ${formatValidAgentNames()}.`,
+        };
+    }
+    if (options.dryRun) {
+        if (options.epic?.dispatch_key && options.keys.length > 1) {
+            return {
+                ok: false,
+                error: "epic.dispatch_key cannot be used with multiple keys: dispatch_key is a single-ticket claim " +
+                    "and would be re-claimed for each key in the batch. Call orchestrateReviewTickets once per ticket instead.",
+            };
+        }
+        const rows = buildReviewPlanRows(deps, options, agent, "dry-run", overrides);
+        return { ok: true, rows };
+    }
+    const preflight = await runReviewTicketsPreflight(deps, options);
+    if (!preflight.ok)
+        return { ok: false, error: preflight.error };
+    // A dispatch_key embeds a single ticket (dispatch:{epic}:{ticket}:{plan_version}).
+    // Claiming the same key for every iteration of a multi-key batch would silently
+    // drop all but the first ticket; reject early with a clear error instead.
+    if (options.epic?.dispatch_key && options.keys.length > 1) {
+        return {
+            ok: false,
+            error: "epic.dispatch_key cannot be used with multiple keys: dispatch_key is a single-ticket claim " +
+                "and would be re-claimed for each key in the batch. Call orchestrateReviewTickets once per ticket instead.",
+        };
+    }
+    const terminal = detectTerminal(undefined, deps.env);
+    const rows = await runWithConcurrency(options.keys, options.maxParallel, async (key) => {
+        const mode = resolveEffectiveReviewMode(key, options);
+        const baseShellCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, options.modelAlias);
+        let shellCommand = baseShellCommand;
+        let runId;
+        if (options.epic) {
+            const mint = overrides.mintRunId ?? mintStartTicketsRunId;
+            runId = mint([key]);
+            const env = { ...buildEpicIdentityEnv(options.epic), BAPI_CONDUCTOR_RUN_ID: runId };
+            shellCommand = injectConductorEnvIntoShellCommand(deps.platform, baseShellCommand, env);
+            if (options.epic.dispatch_key) {
+                if (!overrides.claimEpicDispatch) {
+                    return {
+                        key,
+                        auto: mode.auto,
+                        rounds: mode.rounds,
+                        agentName: options.agentName,
+                        modelAlias: options.modelAlias,
+                        status: "spawn-failed",
+                        command: shellCommand,
+                        runId,
+                        error: "claimEpicDispatch is required when dispatch_key is present but was not provided",
+                    };
+                }
+                try {
+                    await overrides.claimEpicDispatch(options.epic.dispatch_key, runId, deps);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        key,
+                        auto: mode.auto,
+                        rounds: mode.rounds,
+                        agentName: options.agentName,
+                        modelAlias: options.modelAlias,
+                        status: "already-dispatched",
+                        command: shellCommand,
+                        runId,
+                        error: message,
+                    };
+                }
+            }
+        }
+        // worktreePath is named per the spawner API contract but review-tickets passes
+        // the current repo cwd — no Worktrunk worktree is created.
+        const context = { key, worktreePath: deps.cwd };
+        try {
+            const result = await deps.spawnTerminalTab(deps, terminal, shellCommand, context);
+            if (result.ok) {
+                return {
+                    key,
+                    auto: mode.auto,
+                    rounds: mode.rounds,
+                    agentName: options.agentName,
+                    modelAlias: options.modelAlias,
+                    status: "spawned",
+                    command: shellCommand,
+                    runId,
+                };
+            }
+            return {
+                key,
+                auto: mode.auto,
+                rounds: mode.rounds,
+                agentName: options.agentName,
+                modelAlias: options.modelAlias,
+                status: "spawn-failed",
+                command: shellCommand,
+                runId,
+                error: result.error,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                key,
+                auto: mode.auto,
+                rounds: mode.rounds,
+                agentName: options.agentName,
+                modelAlias: options.modelAlias,
+                status: "spawn-failed",
+                command: shellCommand,
+                runId,
+                error: message,
+            };
+        }
+    });
+    return { ok: true, rows };
+}
+// ---------------------------------------------------------------------------
+// Summary formatting
+// ---------------------------------------------------------------------------
+export function formatReviewTicketsSummaryReport(rows) {
+    const lines = ["Summary:"];
+    for (const row of rows) {
+        const modelPart = row.modelAlias ? row.modelAlias : "default";
+        const runIdPart = row.runId ? `  run_id=${row.runId}` : "";
+        lines.push(`${row.key}  auto=${row.auto}  rounds=${row.rounds}  agent=${row.agentName}  model=${modelPart}  status=${row.status}${runIdPart}`);
+    }
+    const failedRows = rows.filter((r) => r.status === "spawn-failed" || r.status === "already-dispatched");
+    if (failedRows.length > 0) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const row of failedRows) {
+            lines.push(`  ${row.key}: ${row.error ?? row.status}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Platform-specific spawn-failure hint
+// ---------------------------------------------------------------------------
+function reviewSpawnFailureHintForPlatform(platform) {
+    if (platform === "darwin") {
+        return ("One or more review tabs failed to spawn. If osascript reported a permission error, grant the " +
+            "required macOS permissions under System Settings -> Privacy & Security, then re-run: " +
+            "Automation (to let the terminal app be controlled) and Accessibility for the new-tab step.");
+    }
+    if (platform === "win32") {
+        return ("One or more review tabs failed to spawn. Ensure Windows Terminal (wt.exe) or PowerShell is " +
+            "installed and on PATH; see the per-ticket warnings above for details.");
+    }
+    if (platform === "linux") {
+        return ("One or more review sessions failed to spawn. Ensure tmux is installed and on PATH; see the " +
+            "per-ticket warnings above for details.");
+    }
+    return "One or more review tabs failed to spawn; see the per-ticket warnings above for details.";
+}
+// ---------------------------------------------------------------------------
+// CLI wrapper
+// ---------------------------------------------------------------------------
+export async function runReviewTicketsCli(argv, overrides = {}) {
+    const log = (m) => console.log(m);
+    const errorLog = (m) => console.error(m);
+    const parsed = parseReviewTicketsArgs(argv);
+    if (parsed.status === "help") {
+        log(parsed.usage);
+        return 0;
+    }
+    if (parsed.status === "error") {
+        errorLog(`Error: ${parsed.message}`);
+        errorLog("");
+        errorLog(getReviewTicketsUsage());
+        return 1;
+    }
+    const options = parsed.options;
+    const deps = overrides.deps ?? createDefaultStartTicketsDeps();
+    if (options.dryRun) {
+        const agent = resolveAgentSpec(options.agentName);
+        if (!agent) {
+            errorLog(`Error: Unknown agent: '${options.agentName}'. Valid agents: ${formatValidAgentNames()}.`);
+            return 1;
+        }
+        const rows = buildReviewPlanRows(deps, options, agent, "dry-run", overrides.orchestrateOverrides);
+        for (const row of rows) {
+            log(`DRY-RUN: ${row.key} -> ${row.command}`);
+        }
+        log("");
+        log(formatReviewTicketsSummaryReport(rows));
+        return 0;
+    }
+    const result = await orchestrateReviewTickets(deps, options, overrides.orchestrateOverrides);
+    if (!result.ok) {
+        errorLog(`Error: ${result.error}`);
+        return 1;
+    }
+    log(formatReviewTicketsSummaryReport(result.rows));
+    const spawned = result.rows.filter((r) => r.status === "spawned");
+    if (deps.platform === "linux" && spawned.length > 0) {
+        log("");
+        log("Linux: each ticket runs in a detached tmux session. Attach with:");
+        for (const row of spawned) {
+            log(`  tmux attach -t ${tmuxSessionNameForTicket(deps, row.key)}`);
+        }
+    }
+    const spawnFailures = result.rows.filter((r) => r.status === "spawn-failed");
+    if (spawnFailures.length > 0) {
+        errorLog("");
+        errorLog(reviewSpawnFailureHintForPlatform(deps.platform));
+    }
+    return 0;
+}

package/build/scheduled-prompt.js

@@ -23,16 +23,16 @@ export function quotePromptToken(token) {
  * the normalized `input.args`, plus (only where the command can parse them)
  * `--scheduled-at <ISO>` and `--auto`.
  *
- * `--scheduled-at` is appended ONLY for the legacy `full-automation` command,
- * whose Stage 0 parses it and whose drift stage consumes it. Every other command
- * rejects unrecognized flags and halts (e.g. `start-tickets` stops on any
- * unsupported flag), and the shared late-fire gate already embeds the scheduled
- * time — so injecting `--scheduled-at` into their argv would break an otherwise
- * `schedulable: true` command for no benefit.
+ * `--scheduled-at` is appended for `full-automation` (legacy) and `epic-tick`
+ * (BAPI-418), both of whose parsers accept it as a first-class argument. Every
+ * other command rejects unrecognized flags and halts (e.g. `start-tickets` stops
+ * on any unsupported flag), and the shared late-fire gate already embeds the
+ * scheduled time — so injecting `--scheduled-at` into their argv would break an
+ * otherwise `schedulable: true` command for no benefit.
  *
  * `--auto` is appended when auto-approve is set AND the command supports it (its
- * schema declares a boolean `--auto` flag, or it is `full-automation`). It is
- * never duplicated if already present in `input.args`.
+ * schema declares a boolean `--auto` flag, or it is `full-automation` / `epic-tick`).
+ * It is never duplicated if already present in `input.args`.
  *
  * This is the SINGLE source of the delegated argv: both the rendered target
  * command line and the `$ARGUMENTS` body substitution derive from it, so the body
@@ -41,10 +41,16 @@ export function quotePromptToken(token) {
  */
 export function buildAugmentedArgs(input) {
     const args = [...input.args];
-    if (input.commandName === "full-automation") {
+    // Commands whose parsers accept --scheduled-at as a first-class argument.
+    // epic-tick already accepts --scheduled-at (parseEpicTickArgs, cli.ts) so it
+    // receives the scheduled time as a structured arg for the late-fire decision,
+    // not just via the embedded gate text.
+    if (input.commandName === "full-automation" || input.commandName === "epic-tick") {
         args.push("--scheduled-at", input.scheduledAt);
     }
-    const supportsAuto = schemaSupportsAutoFlag(input.schema) || input.commandName === "full-automation";
+    const supportsAuto = schemaSupportsAutoFlag(input.schema) ||
+        input.commandName === "full-automation" ||
+        input.commandName === "epic-tick";
     const alreadyHasAuto = input.args.includes("--auto");
     if (input.autoApprove && supportsAuto && !alreadyHasAuto) {
         args.push("--auto");