palmier 0.2.4 → 0.2.5

package/dist/platform/linux.js

@@ -0,0 +1,186 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
+function getTimerName(taskId) {
+    return `palmier-task-${taskId}.timer`;
+}
+function getServiceName(taskId) {
+    return `palmier-task-${taskId}.service`;
+}
+/**
+ * Convert a cron expression to a systemd OnCalendar string.
+ *
+ * Only the 4 cron patterns the PWA UI can produce are supported:
+ *   hourly:  "0 * * * *"
+ *   daily:   "MM HH * * *"
+ *   weekly:  "MM HH * * D"
+ *   monthly: "MM HH D * *"
+ * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
+ * handled because the UI never generates them.
+ */
+function cronToOnCalendar(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+    }
+    const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
+    // Map cron day-of-week numbers to systemd abbreviated names
+    const dowMap = {
+        "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
+        "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
+    };
+    const monthPart = "*";
+    const dayPart = dayOfMonth === "*" ? "*" : dayOfMonth.padStart(2, "0");
+    const hourPart = hour === "*" ? "*" : hour.padStart(2, "0");
+    const minutePart = minute === "*" ? "*" : minute.padStart(2, "0");
+    if (dayOfWeek !== "*") {
+        const dow = dowMap[dayOfWeek] ?? dayOfWeek;
+        return `${dow} *-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
+    }
+    return `*-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
+}
+function daemonReload() {
+    try {
+        execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
+    }
+    catch (err) {
+        const e = err;
+        console.error(`daemon-reload failed: ${e.stderr || err}`);
+    }
+}
+export class LinuxPlatform {
+    installDaemon(config) {
+        fs.mkdirSync(UNIT_DIR, { recursive: true });
+        const palmierBin = process.argv[1] || "palmier";
+        const serviceContent = `[Unit]
+Description=Palmier Host
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${palmierBin} serve
+WorkingDirectory=${config.projectRoot}
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+
+[Install]
+WantedBy=default.target
+`;
+        const servicePath = path.join(UNIT_DIR, "palmier.service");
+        fs.writeFileSync(servicePath, serviceContent, "utf-8");
+        console.log("Systemd service installed at:", servicePath);
+        try {
+            execSync("systemctl --user daemon-reload", { stdio: "inherit" });
+            execSync("systemctl --user enable palmier.service", { stdio: "inherit" });
+            execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
+            console.log("Palmier host service enabled and started.");
+        }
+        catch (err) {
+            console.error(`Warning: failed to enable systemd service: ${err}`);
+            console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
+        }
+        // Enable lingering so service runs without active login session
+        try {
+            execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
+            console.log("Login lingering enabled.");
+        }
+        catch (err) {
+            console.error(`Warning: failed to enable linger: ${err}`);
+        }
+        console.log("\nHost initialization complete!");
+    }
+    installTaskTimer(config, task) {
+        fs.mkdirSync(UNIT_DIR, { recursive: true });
+        const taskId = task.frontmatter.id;
+        const serviceName = getServiceName(taskId);
+        const timerName = getTimerName(taskId);
+        const palmierBin = process.argv[1] || "palmier";
+        const serviceContent = `[Unit]
+Description=Palmier Task: ${taskId}
+
+[Service]
+Type=oneshot
+ExecStart=${palmierBin} run ${taskId}
+WorkingDirectory=${config.projectRoot}
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+`;
+        fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
+        daemonReload();
+        // Only create and enable a timer if there are actual triggers
+        const triggers = task.frontmatter.triggers || [];
+        const onCalendarLines = [];
+        for (const trigger of triggers) {
+            if (trigger.type === "cron") {
+                onCalendarLines.push(`OnCalendar=${cronToOnCalendar(trigger.value)}`);
+            }
+            else if (trigger.type === "once") {
+                onCalendarLines.push(`OnActiveSec=${trigger.value}`);
+            }
+        }
+        if (onCalendarLines.length > 0) {
+            const timerContent = `[Unit]
+Description=Timer for Palmier Task: ${taskId}
+
+[Timer]
+${onCalendarLines.join("\n")}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+            fs.writeFileSync(path.join(UNIT_DIR, timerName), timerContent, "utf-8");
+            daemonReload();
+            try {
+                execSync(`systemctl --user enable --now ${timerName}`, { encoding: "utf-8" });
+            }
+            catch (err) {
+                const e = err;
+                console.error(`Failed to enable timer ${timerName}: ${e.stderr || err}`);
+            }
+        }
+    }
+    removeTaskTimer(taskId) {
+        const timerName = getTimerName(taskId);
+        const serviceName = getServiceName(taskId);
+        const timerPath = path.join(UNIT_DIR, timerName);
+        const servicePath = path.join(UNIT_DIR, serviceName);
+        if (fs.existsSync(timerPath)) {
+            try {
+                execSync(`systemctl --user stop ${timerName}`, { encoding: "utf-8" });
+            }
+            catch { /* timer might not be running */ }
+            try {
+                execSync(`systemctl --user disable ${timerName}`, { encoding: "utf-8" });
+            }
+            catch { /* timer might not be enabled */ }
+            fs.unlinkSync(timerPath);
+        }
+        if (fs.existsSync(servicePath))
+            fs.unlinkSync(servicePath);
+        daemonReload();
+    }
+    async startTask(taskId) {
+        const serviceName = getServiceName(taskId);
+        await execAsync(`systemctl --user start --no-block ${serviceName}`);
+    }
+    async stopTask(taskId) {
+        const serviceName = getServiceName(taskId);
+        await execAsync(`systemctl --user stop ${serviceName}`);
+    }
+    getGuiEnv() {
+        const uid = process.getuid?.();
+        const runtimeDir = process.env.XDG_RUNTIME_DIR ||
+            (uid !== undefined ? `/run/user/${uid}` : "");
+        return {
+            DISPLAY: ":0",
+            ...(runtimeDir ? { XDG_RUNTIME_DIR: runtimeDir } : {}),
+        };
+    }
+}
+//# sourceMappingURL=linux.js.map

package/dist/platform/platform.d.ts

@@ -0,0 +1,20 @@
+import type { HostConfig, ParsedTask } from "../types.js";
+/**
+ * Abstracts OS-specific daemon, scheduling, and process management.
+ * Linux uses systemd; Windows uses Task Scheduler; macOS will use launchd.
+ */
+export interface PlatformService {
+    /** Install the main `palmier serve` daemon to start at boot. */
+    installDaemon(config: HostConfig): void;
+    /** Install a scheduled trigger (timer) for a task. */
+    installTaskTimer(config: HostConfig, task: ParsedTask): void;
+    /** Remove a task's scheduled trigger and service files. */
+    removeTaskTimer(taskId: string): void;
+    /** Start a task execution (non-blocking). */
+    startTask(taskId: string): Promise<void>;
+    /** Abort/stop a running task. */
+    stopTask(taskId: string): Promise<void>;
+    /** Return env vars needed for GUI access (Linux: DISPLAY, etc.). */
+    getGuiEnv(): Record<string, string>;
+}
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform/platform.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=platform.js.map

package/dist/platform/windows.d.ts

@@ -0,0 +1,11 @@
+import type { PlatformService } from "./platform.js";
+import type { HostConfig, ParsedTask } from "../types.js";
+export declare class WindowsPlatform implements PlatformService {
+    installDaemon(config: HostConfig): void;
+    installTaskTimer(config: HostConfig, task: ParsedTask): void;
+    removeTaskTimer(taskId: string): void;
+    startTask(taskId: string): Promise<void>;
+    stopTask(taskId: string): Promise<void>;
+    getGuiEnv(): Record<string, string>;
+}
+//# sourceMappingURL=windows.d.ts.map

package/dist/platform/windows.js

@@ -0,0 +1,201 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync, exec, spawn as nodeSpawn } from "child_process";
+import { promisify } from "util";
+import { getTaskDir } from "../task.js";
+import { loadConfig } from "../config.js";
+const execAsync = promisify(exec);
+const TASK_PREFIX = "PalmierTask-";
+const DAEMON_TASK_NAME = "PalmierDaemon";
+const SHELL = "cmd.exe";
+/**
+ * Resolve the full command to invoke palmier, accounting for the fact that
+ * on Windows, globally-installed npm packages are .cmd shims.
+ */
+function getPalmierCommand() {
+    // process.argv[1] is the script path; wrap with node so it works as
+    // a Task Scheduler command without relying on file associations.
+    const script = process.argv[1] || "palmier";
+    return `"${process.execPath}" "${script}"`;
+}
+/**
+ * Convert one of the 4 supported cron patterns to schtasks flags.
+ *
+ * Only these patterns (produced by the PWA UI) are handled:
+ *   hourly:  "0 * * * *"        → /sc HOURLY
+ *   daily:   "MM HH * * *"      → /sc DAILY /st HH:MM
+ *   weekly:  "MM HH * * D"      → /sc WEEKLY /d <day> /st HH:MM
+ *   monthly: "MM HH D * *"      → /sc MONTHLY /d D /st HH:MM
+ *
+ * Arbitrary cron expressions (ranges, lists, step values) are NOT handled
+ * because the UI never generates them.
+ */
+function cronToSchtasksArgs(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+    }
+    const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
+    // Map cron day-of-week numbers to schtasks day abbreviations
+    const dowMap = {
+        "0": "SUN", "1": "MON", "2": "TUE", "3": "WED",
+        "4": "THU", "5": "FRI", "6": "SAT", "7": "SUN",
+    };
+    const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+    // Hourly: "0 * * * *"
+    if (hour === "*" && dayOfMonth === "*" && dayOfWeek === "*") {
+        return ["/sc", "HOURLY"];
+    }
+    // Weekly: "MM HH * * D"
+    if (dayOfMonth === "*" && dayOfWeek !== "*") {
+        const day = dowMap[dayOfWeek];
+        if (!day)
+            throw new Error(`Unsupported day-of-week: ${dayOfWeek}`);
+        return ["/sc", "WEEKLY", "/d", day, "/st", st];
+    }
+    // Monthly: "MM HH D * *"
+    if (dayOfMonth !== "*" && dayOfWeek === "*") {
+        return ["/sc", "MONTHLY", "/d", dayOfMonth, "/st", st];
+    }
+    // Daily: "MM HH * * *"  (most common fallback)
+    return ["/sc", "DAILY", "/st", st];
+}
+function schtasksTaskName(taskId) {
+    return `${TASK_PREFIX}${taskId}`;
+}
+export class WindowsPlatform {
+    installDaemon(config) {
+        const cmd = getPalmierCommand();
+        // Try ONSTART first (requires elevation), fall back to ONLOGON
+        const baseArgs = [
+            "/create", "/tn", DAEMON_TASK_NAME,
+            "/tr", `${cmd} serve`,
+            "/rl", "HIGHEST",
+            "/f", // force overwrite if exists
+        ];
+        try {
+            execSync(`schtasks ${[...baseArgs, "/sc", "ONSTART"].join(" ")}`, { encoding: "utf-8", shell: SHELL });
+            console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at startup).`);
+        }
+        catch {
+            // ONSTART requires admin — fall back to ONLOGON which does not
+            try {
+                execSync(`schtasks ${[...baseArgs, "/sc", "ONLOGON"].join(" ")}`, { encoding: "utf-8", shell: SHELL });
+                console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at logon).`);
+                console.log("  Tip: run as Administrator to use ONSTART instead.");
+            }
+            catch (err) {
+                console.error(`Warning: failed to create scheduled task: ${err}`);
+                console.error("You may need to start palmier serve manually.");
+            }
+        }
+        // Start the daemon now
+        try {
+            execSync(`schtasks /run /tn ${DAEMON_TASK_NAME}`, { encoding: "utf-8", shell: SHELL });
+            console.log("Palmier daemon started.");
+        }
+        catch {
+            console.log("Note: could not start daemon immediately. It will start at next login/boot.");
+        }
+        console.log("\nHost initialization complete!");
+    }
+    installTaskTimer(config, task) {
+        const taskId = task.frontmatter.id;
+        const tn = schtasksTaskName(taskId);
+        const cmd = getPalmierCommand();
+        const triggers = task.frontmatter.triggers || [];
+        for (const trigger of triggers) {
+            if (trigger.type === "cron") {
+                const schedArgs = cronToSchtasksArgs(trigger.value);
+                const args = [
+                    "/create", "/tn", tn,
+                    "/tr", `${cmd} run ${taskId}`,
+                    ...schedArgs,
+                    "/f",
+                ];
+                try {
+                    execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+                }
+                catch (err) {
+                    const e = err;
+                    console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
+                }
+            }
+            else if (trigger.type === "once") {
+                // "once" triggers use ISO datetime: "2026-03-28T09:00"
+                const [datePart, timePart] = trigger.value.split("T");
+                if (!datePart || !timePart) {
+                    console.error(`Invalid once trigger value: ${trigger.value}`);
+                    continue;
+                }
+                // schtasks expects MM/DD/YYYY date format
+                const [year, month, day] = datePart.split("-");
+                const sd = `${month}/${day}/${year}`;
+                const st = timePart.slice(0, 5);
+                const args = [
+                    "/create", "/tn", tn,
+                    "/tr", `${cmd} run ${taskId}`,
+                    "/sc", "ONCE", "/sd", sd, "/st", st,
+                    "/f",
+                ];
+                try {
+                    execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+                }
+                catch (err) {
+                    const e = err;
+                    console.error(`Failed to create once task ${tn}: ${e.stderr || err}`);
+                }
+            }
+        }
+    }
+    removeTaskTimer(taskId) {
+        const tn = schtasksTaskName(taskId);
+        try {
+            execSync(`schtasks /delete /tn ${tn} /f`, { encoding: "utf-8", shell: SHELL });
+        }
+        catch {
+            // Task might not exist — that's fine
+        }
+    }
+    async startTask(taskId) {
+        const config = loadConfig();
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        const script = process.argv[1] || "palmier";
+        // Spawn a detached child process and record its PID for later abort
+        const child = nodeSpawn(process.execPath, [script, "run", taskId], {
+            detached: true,
+            stdio: "ignore",
+            cwd: config.projectRoot,
+        });
+        if (child.pid) {
+            fs.mkdirSync(taskDir, { recursive: true });
+            fs.writeFileSync(path.join(taskDir, "pid"), String(child.pid), "utf-8");
+        }
+        child.unref();
+    }
+    async stopTask(taskId) {
+        const config = loadConfig();
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        const pidPath = path.join(taskDir, "pid");
+        if (!fs.existsSync(pidPath)) {
+            throw new Error(`No PID file found for task ${taskId}`);
+        }
+        const pid = fs.readFileSync(pidPath, "utf-8").trim();
+        try {
+            // /t kills the entire process tree, /f forces termination
+            await execAsync(`taskkill /pid ${pid} /t /f`);
+        }
+        finally {
+            // Clean up PID file regardless of whether taskkill succeeded
+            try {
+                fs.unlinkSync(pidPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    getGuiEnv() {
+        // Windows GUI is always available — no special env vars needed
+        return {};
+    }
+}
+//# sourceMappingURL=windows.js.map

package/dist/rpc-handler.js

@@ -1,17 +1,14 @@
 import { randomUUID } from "crypto";
 import * as os from "os";
-import { execSync, exec } from "child_process";
-import { promisify } from "util";
-const execAsync = promisify(exec);
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, getTaskCreatedAt, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
-import { installTaskTimer, removeTaskTimer } from "./systemd.js";
+import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
-import { hasSessions, validateSession } from "./session-store.js";
+import { validateSession } from "./session-store.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PLAN_GENERATION_PROMPT = fs.readFileSync(path.join(__dirname, "commands", "plan-generation.md"), "utf-8");
 function detectLanIp() {
@@ -110,11 +107,9 @@ export function createRpcHandler(config) {
         };
     }
     async function handleRpc(request) {
-        // Session token validation: if any sessions exist, require a valid token
-        if (hasSessions()) {
-            if (!request.sessionToken || !validateSession(request.sessionToken)) {
-                return { error: "Unauthorized" };
-            }
+        // Session token validation: always require a valid session token
+        if (!request.sessionToken || !validateSession(request.sessionToken)) {
+            return { error: "Unauthorized" };
         }
         switch (request.method) {
             case "task.list": {
@@ -159,8 +154,9 @@ export function createRpcHandler(config) {
                 };
                 writeTaskFile(taskDir, task);
                 appendTaskList(config.projectRoot, id);
+                const platform = getPlatform();
                 if (task.frontmatter.triggers_enabled) {
-                    installTaskTimer(config, task);
+                    platform.installTaskTimer(config, task);
                 }
                 return flattenTask(task);
             }
@@ -203,23 +199,23 @@ export function createRpcHandler(config) {
                 }
                 writeTaskFile(taskDir, existing);
                 // Reinstall or remove timers based on triggers_enabled
-                removeTaskTimer(params.id);
+                const platform = getPlatform();
+                platform.removeTaskTimer(params.id);
                 if (existing.frontmatter.triggers_enabled) {
-                    installTaskTimer(config, existing);
+                    platform.installTaskTimer(config, existing);
                 }
                 return flattenTask(existing);
             }
             case "task.delete": {
                 const params = request.params;
-                removeTaskTimer(params.id);
+                getPlatform().removeTaskTimer(params.id);
                 removeFromTaskList(config.projectRoot, params.id);
                 return { ok: true, task_id: params.id };
             }
             case "task.run": {
                 const params = request.params;
-                const serviceName = `palmier-task-${params.id}.service`;
                 try {
-                    await execAsync(`systemctl --user start --no-block ${serviceName}`);
+                    await getPlatform().startTask(params.id);
                     return { ok: true, task_id: params.id };
                 }
                 catch (err) {
@@ -230,9 +226,8 @@ export function createRpcHandler(config) {
             }
             case "task.abort": {
                 const params = request.params;
-                const serviceName = `palmier-task-${params.id}.service`;
                 try {
-                    await execAsync(`systemctl --user stop ${serviceName}`);
+                    await getPlatform().stopTask(params.id);
                     return { ok: true, task_id: params.id };
                 }
                 catch (err) {
@@ -241,18 +236,6 @@ export function createRpcHandler(config) {
                     return { error: `Failed to abort task: ${e.stderr || e.message}` };
                 }
             }
-            case "task.logs": {
-                const params = request.params;
-                const serviceName = `palmier-task-${params.id}.service`;
-                try {
-                    const logs = execSync(`journalctl --user -u ${serviceName} -n 100 --no-pager`, { encoding: "utf-8" });
-                    return { task_id: params.id, logs };
-                }
-                catch (err) {
-                    const error = err;
-                    return { task_id: params.id, logs: error.stdout || "", error: error.stderr };
-                }
-            }
             case "task.status": {
                 const params = request.params;
                 const taskDir = getTaskDir(config.projectRoot, params.id);

package/dist/spawn-command.d.ts

@@ -12,8 +12,11 @@ export interface SpawnCommandOptions {
 /**
  * Spawn a command with additional arguments.
  *
- * Runs without a shell — the command and args are passed directly to the
- * child process (no escaping needed).
+ * On Windows, `shell: true` is used so that npm-installed .cmd shims
+ * (e.g. claude.cmd, gemini.cmd) are resolved correctly.
+ *
+ * On other platforms the command is executed directly (no shell), so no
+ * escaping is needed.
  *
  * stdin is set to "ignore" (equivalent to < /dev/null) because tools like
  * `claude -p` hang indefinitely on an open stdin pipe.

package/dist/spawn-command.js

@@ -5,6 +5,8 @@ export function spawnCommand(command, args, opts) {
             cwd: opts.cwd,
             stdio: ["ignore", "pipe", "pipe"],
             env: opts.env ? { ...process.env, ...opts.env } : undefined,
+            // On Windows, spawn through shell so .cmd shims resolve correctly
+            shell: process.platform === "win32",
         });
         const chunks = [];
         child.stdout.on("data", (d) => {

package/dist/transports/http-transport.js

@@ -1,6 +1,6 @@
 import * as http from "node:http";
 import * as os from "os";
-import { validateSession, hasSessions, addSession } from "../session-store.js";
+import { validateSession, addSession } from "../session-store.js";
 const pendingPairs = new Map();
 export function detectLanIp() {
     const interfaces = os.networkInterfaces();
@@ -35,12 +35,7 @@ export async function startHttpTransport(config, handleRpc) {
         if (!auth || !auth.startsWith("Bearer "))
             return false;
         const token = auth.slice(7);
-        // Accept the original directToken or any valid session token
-        if (token === config.directToken)
-            return true;
-        if (hasSessions() && validateSession(token))
-            return true;
-        return false;
+        return validateSession(token);
     }
     function extractSessionToken(req) {
         const auth = req.headers.authorization;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "ISC",
   "author": "Hongxu Cai",

package/src/agents/claude.ts

@@ -3,6 +3,10 @@ import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
 import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
 
+// execSync's shell option takes a string (shell path), not boolean.
+// On Windows we need a shell so .cmd shims resolve correctly.
+const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
+
 export class ClaudeAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
@@ -25,12 +29,12 @@ export class ClaudeAgent implements AgentTool {
 
   async init(): Promise<boolean> {
     try {
-      execSync("claude --version");
+      execSync("claude --version", { shell: SHELL });
     } catch {
       return false;
     }
     try {
-      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver");
+      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { shell: SHELL });
     } catch (err) {
       console.warn("Warning: failed to install MCP for Claude:", err instanceof Error ? err.message : err);
     }

package/src/agents/codex.ts

@@ -3,6 +3,9 @@ import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
 import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
 
+// On Windows we need a shell so .cmd shims resolve correctly.
+const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
+
 export class CodexAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     // TODO: fill in
@@ -32,12 +35,12 @@ export class CodexAgent implements AgentTool {
 
   async init(): Promise<boolean> {
     try {
-      execSync("codex --version");
+      execSync("codex --version", { shell: SHELL });
     } catch {
       return false;
     }
     try {
-      execSync("codex mcp add palmier palmier mcpserver");
+      execSync("codex mcp add palmier palmier mcpserver", { shell: SHELL });
     } catch (err) {
       console.warn("Warning: failed to install MCP for Codex:", err instanceof Error ? err.message : err);
     }

package/src/agents/gemini.ts

@@ -3,6 +3,9 @@ import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
 import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
 
+// On Windows we need a shell so .cmd shims resolve correctly.
+const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
+
 export class GeminiAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     // TODO: fill in
@@ -29,12 +32,12 @@ export class GeminiAgent implements AgentTool {
 
   async init(): Promise<boolean> {
     try {
-      execSync("gemini --version");
+      execSync("gemini --version", { shell: SHELL });
     } catch {
       return false;
     }
     try {
-      execSync("gemini mcp add --scope user palmier palmier mcpserver");
+      execSync("gemini mcp add --scope user palmier palmier mcpserver", { shell: SHELL });
     } catch (err) {
       console.warn("Warning: failed to install MCP for Gemini:", err instanceof Error ? err.message : err);
     }