palmier 0.3.3 → 0.3.5

package/.github/workflows/ci.yml

@@ -13,4 +13,4 @@ jobs:
           cache: npm
       - run: npm ci
       - run: npm run build
-      # - run: npm test
+      - run: npm test

package/README.md

@@ -26,7 +26,7 @@ The host supports two independent connection modes, enabled during `palmier init
 ## Prerequisites
 
 - **Node.js 24+**
-- An agent CLI tool for task execution (e.g., Claude Code, Gemini CLI, OpenAI Codex)
+- An agent CLI tool for task execution (e.g., Claude Code, Gemini CLI, OpenAI Codex, GitHub Copilot)
 - **Linux with systemd** or **Windows 10/11**
 
 ## Installation
@@ -83,7 +83,7 @@ palmier sessions revoke-all
 ```
 
 The `init` command:
-- Detects installed agent CLIs (Claude Code, Gemini CLI, Codex CLI) and caches the result
+- Detects installed agent CLIs (Claude Code, Gemini CLI, Codex CLI, GitHub Copilot) and caches the result
 - Saves host configuration to `~/.config/palmier/host.json`
 - Installs a background daemon (systemd user service on Linux, Registry Run key on Windows)
 - Auto-enters pair mode to connect your first device
@@ -162,6 +162,7 @@ src/
     claude.ts         # Claude Code agent implementation
     gemini.ts         # Gemini CLI agent implementation
     codex.ts          # Codex CLI agent implementation
+    copilot.ts        # GitHub Copilot agent implementation
     openclaw.ts       # OpenClaw agent implementation
   commands/
     init.ts           # Interactive setup wizard (auto-pair)

package/dist/agents/agent.js

@@ -2,17 +2,20 @@ import { ClaudeAgent } from "./claude.js";
 import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
 import { OpenClawAgent } from "./openclaw.js";
+import { CopilotAgent } from "./copilot.js";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
     codex: new CodexAgent(),
     openclaw: new OpenClawAgent(),
+    copilot: new CopilotAgent(),
 };
 const agentLabels = {
     claude: "Claude Code",
     gemini: "Gemini CLI",
     codex: "Codex CLI",
-    openclaw: "OpenClaw"
+    openclaw: "OpenClaw",
+    copilot: "GitHub Copilot",
 };
 export async function detectAgents() {
     const detected = [];

package/dist/agents/copilot.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class CopilotAgent implements AgentTool {
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=copilot.d.ts.map

package/dist/agents/copilot.js

@@ -0,0 +1,53 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class CopilotAgent {
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "copilot",
+            args: ["-p", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
+        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+        const args = ["-p", prompt];
+        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+        if (allPerms.length > 0) {
+            args.push("--allow-tool", allPerms.map((p) => p.name).join(","));
+        }
+        if (retryPrompt) {
+            args.push("--continue");
+        }
+        return { command: "copilot", args };
+    }
+    async init() {
+        try {
+            execSync("copilot -v", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        // Register Palmier MCP server in ~/.copilot/mcp-config.json
+        try {
+            const configDir = path.join(homedir(), ".copilot");
+            const configFile = path.join(configDir, "mcp-config.json");
+            let config = {};
+            if (fs.existsSync(configFile)) {
+                config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+            }
+            const servers = (config.mcpServers ?? {});
+            servers.palmier = { command: "palmier", args: ["mcpserver"] };
+            config.mcpServers = servers;
+            fs.mkdirSync(configDir, { recursive: true });
+            fs.writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
+        }
+        catch {
+            // MCP registration is best-effort
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=copilot.js.map

package/dist/commands/run.d.ts

@@ -1,5 +1,26 @@
+import type { TaskRunningState, RequiredPermission } from "../types.js";
 /**
  * Execute a task by ID.
  */
 export declare function runCommand(taskId: string): Promise<void>;
+/**
+ * Extract report file names from agent output.
+ * Looks for lines matching: [PALMIER_REPORT] <filename>
+ */
+export declare function parseReportFiles(output: string): string[];
+/**
+ * Extract required permissions from agent output.
+ * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
+ */
+export declare function parsePermissions(output: string): RequiredPermission[];
+/**
+ * Extract user input requests from agent output.
+ * Looks for lines matching: [PALMIER_INPUT] <description>
+ */
+export declare function parseInputRequests(output: string): string[];
+/**
+ * Parse the agent's output for success/failure markers.
+ * Falls back to "finished" if no marker is found.
+ */
+export declare function parseTaskOutcome(output: string): TaskRunningState;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/run.js

@@ -405,7 +405,7 @@ async function requestConfirmation(nc, config, task, taskDir) {
  * Extract report file names from agent output.
  * Looks for lines matching: [PALMIER_REPORT] <filename>
  */
-function parseReportFiles(output) {
+export function parseReportFiles(output) {
     const regex = new RegExp(`^\\${TASK_REPORT_PREFIX}\\s+(.+)$`, "gm");
     const files = [];
     let match;
@@ -420,7 +420,7 @@ function parseReportFiles(output) {
  * Extract required permissions from agent output.
  * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
  */
-function parsePermissions(output) {
+export function parsePermissions(output) {
     const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
     const perms = [];
     let match;
@@ -440,7 +440,7 @@ function parsePermissions(output) {
  * Extract user input requests from agent output.
  * Looks for lines matching: [PALMIER_INPUT] <description>
  */
-function parseInputRequests(output) {
+export function parseInputRequests(output) {
     const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
     const inputs = [];
     let match;
@@ -455,7 +455,7 @@ function parseInputRequests(output) {
  * Parse the agent's output for success/failure markers.
  * Falls back to "finished" if no marker is found.
  */
-function parseTaskOutcome(output) {
+export function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
     if (lastChunk.includes(TASK_FAILURE_MARKER))
         return "failed";

package/dist/platform/linux.d.ts

@@ -1,5 +1,17 @@
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
+/**
+ * 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.
+ */
+export declare function cronToOnCalendar(cron: string): string;
 export declare class LinuxPlatform implements PlatformService {
     installDaemon(config: HostConfig): void;
     restartDaemon(): Promise<void>;

package/dist/platform/linux.js

@@ -22,7 +22,7 @@ function getServiceName(taskId) {
  * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
  * handled because the UI never generates them.
  */
-function cronToOnCalendar(cron) {
+export function cronToOnCalendar(cron) {
     const parts = cron.trim().split(/\s+/);
     if (parts.length !== 5) {
         throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);

package/dist/platform/windows.d.ts

@@ -1,5 +1,22 @@
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
+/**
+ * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
+ *
+ * Only these cron patterns (produced by the PWA UI) are handled:
+ *   hourly:  "0 * * * *"
+ *   daily:   "MM HH * * *"
+ *   weekly:  "MM HH * * D"
+ *   monthly: "MM HH D * *"
+ */
+export declare function triggerToXml(trigger: {
+    type: string;
+    value: string;
+}): string;
+/**
+ * Build a complete Task Scheduler XML definition.
+ */
+export declare function buildTaskXml(tr: string, triggers: string[]): string;
 export declare class WindowsPlatform implements PlatformService {
     installDaemon(config: HostConfig): void;
     restartDaemon(): Promise<void>;

package/dist/platform/windows.js

@@ -15,47 +15,69 @@ function schtasksTr(...subcommand) {
     const script = process.argv[1] || "palmier";
     return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
 }
+const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 /**
- * Convert one of the 4 supported cron patterns to schtasks flags.
+ * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
  *
- * 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.
+ * Only these cron patterns (produced by the PWA UI) are handled:
+ *   hourly:  "0 * * * *"
+ *   daily:   "MM HH * * *"
+ *   weekly:  "MM HH * * D"
+ *   monthly: "MM HH D * *"
  */
-function cronToSchtasksArgs(cron) {
-    const parts = cron.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+export function triggerToXml(trigger) {
+    if (trigger.type === "once") {
+        // ISO datetime "2026-03-28T09:00"
+        return `<TimeTrigger><StartBoundary>${trigger.value}:00</StartBoundary></TimeTrigger>`;
     }
+    const parts = trigger.value.trim().split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`Invalid cron expression: ${trigger.value}`);
     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"];
+    const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
+    // StartBoundary needs a full date; use a past date as the anchor
+    const base = `2000-01-01T${st}`;
+    // Hourly
+    if (hour === "*") {
+        return `<TimeTrigger><StartBoundary>${base}</StartBoundary><Repetition><Interval>PT1H</Interval></Repetition></TimeTrigger>`;
     }
-    // Weekly: "MM HH * * D"
+    // Weekly
     if (dayOfMonth === "*" && dayOfWeek !== "*") {
-        const day = dowMap[dayOfWeek];
-        if (!day)
-            throw new Error(`Unsupported day-of-week: ${dayOfWeek}`);
-        return ["/sc", "WEEKLY", "/d", day, "/st", st];
+        const day = DOW_NAMES[Number(dayOfWeek)] ?? "Monday";
+        return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByWeek><DaysOfWeek><${day} /></DaysOfWeek><WeeksInterval>1</WeeksInterval></ScheduleByWeek></CalendarTrigger>`;
     }
-    // Monthly: "MM HH D * *"
+    // Monthly
     if (dayOfMonth !== "*" && dayOfWeek === "*") {
-        return ["/sc", "MONTHLY", "/d", dayOfMonth, "/st", st];
+        return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByMonth><DaysOfMonth><Day>${dayOfMonth}</Day></DaysOfMonth><Months><January /><February /><March /><April /><May /><June /><July /><August /><September /><October /><November /><December /></Months></ScheduleByMonth></CalendarTrigger>`;
     }
-    // Daily: "MM HH * * *"  (most common fallback)
-    return ["/sc", "DAILY", "/st", st];
+    // Daily
+    return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger>`;
+}
+/**
+ * Build a complete Task Scheduler XML definition.
+ */
+export function buildTaskXml(tr, triggers) {
+    const [command, ...argParts] = tr.match(/"[^"]*"|[^\s]+/g) ?? [];
+    const commandStr = command?.replace(/"/g, "") ?? "";
+    const argsStr = argParts.map((a) => a.replace(/"/g, "")).join(" ");
+    return [
+        `<?xml version="1.0" encoding="UTF-16"?>`,
+        `<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">`,
+        `  <Settings>`,
+        `    <MultipleInstancesPolicy>StopExisting</MultipleInstancesPolicy>`,
+        `    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>`,
+        `    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>`,
+        `    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>`,
+        `  </Settings>`,
+        `  <Triggers>${triggers.join("")}</Triggers>`,
+        `  <Actions>`,
+        `    <Exec>`,
+        `      <Command>${commandStr}</Command>`,
+        `      <Arguments>${argsStr}</Arguments>`,
+        `    </Exec>`,
+        `  </Actions>`,
+        `</Task>`,
+    ].join("\n");
 }
 function schtasksTaskName(taskId) {
     return `${TASK_PREFIX}${taskId}`;
@@ -113,64 +135,43 @@ export class WindowsPlatform {
         const taskId = task.frontmatter.id;
         const tn = schtasksTaskName(taskId);
         const tr = schtasksTr("run", taskId);
-        // Always create the scheduled task with a dummy trigger first.
-        // This ensures startTask (/run) works even when no triggers are configured.
+        // Build trigger XML elements
+        const triggerElements = [];
+        if (task.frontmatter.triggers_enabled) {
+            for (const trigger of task.frontmatter.triggers ?? []) {
+                try {
+                    triggerElements.push(triggerToXml(trigger));
+                }
+                catch (err) {
+                    console.error(`Invalid trigger: ${err}`);
+                }
+            }
+        }
+        // Always include a dummy trigger so startTask (/run) works
+        if (triggerElements.length === 0) {
+            triggerElements.push(`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`);
+        }
+        // Write XML and register via schtasks — gives us full control over
+        // settings like MultipleInstancesPolicy that schtasks flags don't expose.
+        const xml = buildTaskXml(tr, triggerElements);
+        const xmlPath = path.join(CONFIG_DIR, `task-${taskId}.xml`);
         try {
+            // schtasks /xml requires UTF-16LE with BOM
+            const bom = Buffer.from([0xFF, 0xFE]);
+            fs.writeFileSync(xmlPath, Buffer.concat([bom, Buffer.from(xml, "utf16le")]));
             execFileSync("schtasks", [
-                "/create", "/tn", tn,
-                "/tr", tr,
-                "/sc", "ONCE", "/sd", "01/01/2000", "/st", "00:00",
-                "/f",
+                "/create", "/tn", tn, "/xml", xmlPath, "/f",
             ], { encoding: "utf-8", windowsHide: true });
         }
         catch (err) {
             const e = err;
             console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
         }
-        // Overlay with real schedule triggers if enabled
-        if (!task.frontmatter.triggers_enabled)
-            return;
-        const triggers = task.frontmatter.triggers || [];
-        for (const trigger of triggers) {
-            if (trigger.type === "cron") {
-                const schedArgs = cronToSchtasksArgs(trigger.value);
-                try {
-                    execFileSync("schtasks", [
-                        "/create", "/tn", tn,
-                        "/tr", tr,
-                        ...schedArgs,
-                        "/f",
-                    ], { encoding: "utf-8", windowsHide: true });
-                }
-                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);
-                try {
-                    execFileSync("schtasks", [
-                        "/create", "/tn", tn,
-                        "/tr", tr,
-                        "/sc", "ONCE", "/sd", sd, "/st", st,
-                        "/f",
-                    ], { encoding: "utf-8", windowsHide: true });
-                }
-                catch (err) {
-                    const e = err;
-                    console.error(`Failed to create once task ${tn}: ${e.stderr || err}`);
-                }
+        finally {
+            try {
+                fs.unlinkSync(xmlPath);
             }
+            catch { /* ignore */ }
         }
     }
     removeTaskTimer(taskId) {

package/dist/task.d.ts

@@ -3,6 +3,10 @@ import type { ParsedTask, TaskStatus, HistoryEntry } from "./types.js";
  * Parse a TASK.md file from the given task directory.
  */
 export declare function parseTaskFile(taskDir: string): ParsedTask;
+/**
+ * Parse TASK.md content string into frontmatter + body.
+ */
+export declare function parseTaskContent(content: string): ParsedTask;
 /**
  * Write a TASK.md file to the given task directory.
  * Creates the directory if it doesn't exist.

package/dist/task.js

@@ -15,7 +15,7 @@ export function parseTaskFile(taskDir) {
 /**
  * Parse TASK.md content string into frontmatter + body.
  */
-function parseTaskContent(content) {
+export function parseTaskContent(content) {
     const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
     const match = content.match(fmRegex);
     if (!match) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",
@@ -21,6 +21,7 @@
   "scripts": {
     "dev": "tsx src/index.ts",
     "build": "tsc && node -e \"require('fs').cpSync('src/commands/plan-generation.md','dist/commands/plan-generation.md')\"",
+    "test": "tsx --test test/**/*.test.ts",
     "prepare": "npm run build",
     "start": "node dist/index.js"
   },

package/src/agents/agent.ts

@@ -3,6 +3,7 @@ import { ClaudeAgent } from "./claude.js";
 import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
 import { OpenClawAgent } from "./openclaw.js";
+import { CopilotAgent } from "./copilot.js";
 
 export interface CommandLine {
   command: string;
@@ -34,13 +35,15 @@ const agentRegistry: Record<string, AgentTool> = {
   gemini: new GeminiAgent(),
   codex: new CodexAgent(),
   openclaw: new OpenClawAgent(),
+  copilot: new CopilotAgent(),
 };
 
 const agentLabels: Record<string, string> = {
   claude: "Claude Code",
   gemini: "Gemini CLI",
   codex: "Codex CLI",
-  openclaw: "OpenClaw"
+  openclaw: "OpenClaw",
+  copilot: "GitHub Copilot",
 };
 
 export interface DetectedAgent {

package/src/agents/copilot.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class CopilotAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "copilot",
+      args: ["-p", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    const args = ["-p", prompt];
+
+    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+    if (allPerms.length > 0) {
+      args.push("--allow-tool", allPerms.map((p) => p.name).join(","));
+    }
+
+    if (retryPrompt) { args.push("--continue"); }
+    return { command: "copilot", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("copilot -v", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    // Register Palmier MCP server in ~/.copilot/mcp-config.json
+    try {
+      const configDir = path.join(homedir(), ".copilot");
+      const configFile = path.join(configDir, "mcp-config.json");
+      let config: Record<string, unknown> = {};
+      if (fs.existsSync(configFile)) {
+        config = JSON.parse(fs.readFileSync(configFile, "utf-8")) as Record<string, unknown>;
+      }
+      const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
+      servers.palmier = { command: "palmier", args: ["mcpserver"] };
+      config.mcpServers = servers;
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
+    } catch {
+      // MCP registration is best-effort
+    }
+    return true;
+  }
+}

package/src/commands/run.ts

@@ -536,7 +536,7 @@ async function requestConfirmation(
  * Extract report file names from agent output.
  * Looks for lines matching: [PALMIER_REPORT] <filename>
  */
-function parseReportFiles(output: string): string[] {
+export function parseReportFiles(output: string): string[] {
   const regex = new RegExp(`^\\${TASK_REPORT_PREFIX}\\s+(.+)$`, "gm");
   const files: string[] = [];
   let match;
@@ -551,7 +551,7 @@ function parseReportFiles(output: string): string[] {
  * Extract required permissions from agent output.
  * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
  */
-function parsePermissions(output: string): RequiredPermission[] {
+export function parsePermissions(output: string): RequiredPermission[] {
   const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
   const perms: RequiredPermission[] = [];
   let match;
@@ -571,7 +571,7 @@ function parsePermissions(output: string): RequiredPermission[] {
  * Extract user input requests from agent output.
  * Looks for lines matching: [PALMIER_INPUT] <description>
  */
-function parseInputRequests(output: string): string[] {
+export function parseInputRequests(output: string): string[] {
   const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
   const inputs: string[] = [];
   let match;
@@ -586,7 +586,7 @@ function parseInputRequests(output: string): string[] {
  * Parse the agent's output for success/failure markers.
  * Falls back to "finished" if no marker is found.
  */
-function parseTaskOutcome(output: string): TaskRunningState {
+export function parseTaskOutcome(output: string): TaskRunningState {
   const lastChunk = output.slice(-500);
   if (lastChunk.includes(TASK_FAILURE_MARKER)) return "failed";
   if (lastChunk.includes(TASK_SUCCESS_MARKER)) return "finished";

package/src/platform/linux.ts

@@ -29,7 +29,7 @@ function getServiceName(taskId: string): string {
  * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
  * handled because the UI never generates them.
  */
-function cronToOnCalendar(cron: string): string {
+export function cronToOnCalendar(cron: string): string {
   const parts = cron.trim().split(/\s+/);
   if (parts.length !== 5) {
     throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);

package/src/platform/windows.ts

@@ -21,53 +21,76 @@ function schtasksTr(...subcommand: string[]): string {
   return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
 }
 
+const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+
 /**
- * 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
+ * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
  *
- * Arbitrary cron expressions (ranges, lists, step values) are NOT handled
- * because the UI never generates them.
+ * Only these cron patterns (produced by the PWA UI) are handled:
+ *   hourly:  "0 * * * *"
+ *   daily:   "MM HH * * *"
+ *   weekly:  "MM HH * * D"
+ *   monthly: "MM HH D * *"
  */
-function cronToSchtasksArgs(cron: string): string[] {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+export function triggerToXml(trigger: { type: string; value: string }): string {
+  if (trigger.type === "once") {
+    // ISO datetime "2026-03-28T09:00"
+    return `<TimeTrigger><StartBoundary>${trigger.value}:00</StartBoundary></TimeTrigger>`;
   }
 
+  const parts = trigger.value.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron expression: ${trigger.value}`);
   const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
+  const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
+  // StartBoundary needs a full date; use a past date as the anchor
+  const base = `2000-01-01T${st}`;
 
-  // Map cron day-of-week numbers to schtasks day abbreviations
-  const dowMap: Record<string, string> = {
-    "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"];
+  // Hourly
+  if (hour === "*") {
+    return `<TimeTrigger><StartBoundary>${base}</StartBoundary><Repetition><Interval>PT1H</Interval></Repetition></TimeTrigger>`;
   }
 
-  // Weekly: "MM HH * * D"
+  // Weekly
   if (dayOfMonth === "*" && dayOfWeek !== "*") {
-    const day = dowMap[dayOfWeek];
-    if (!day) throw new Error(`Unsupported day-of-week: ${dayOfWeek}`);
-    return ["/sc", "WEEKLY", "/d", day, "/st", st];
+    const day = DOW_NAMES[Number(dayOfWeek)] ?? "Monday";
+    return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByWeek><DaysOfWeek><${day} /></DaysOfWeek><WeeksInterval>1</WeeksInterval></ScheduleByWeek></CalendarTrigger>`;
   }
 
-  // Monthly: "MM HH D * *"
+  // Monthly
   if (dayOfMonth !== "*" && dayOfWeek === "*") {
-    return ["/sc", "MONTHLY", "/d", dayOfMonth, "/st", st];
+    return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByMonth><DaysOfMonth><Day>${dayOfMonth}</Day></DaysOfMonth><Months><January /><February /><March /><April /><May /><June /><July /><August /><September /><October /><November /><December /></Months></ScheduleByMonth></CalendarTrigger>`;
   }
 
-  // Daily: "MM HH * * *"  (most common fallback)
-  return ["/sc", "DAILY", "/st", st];
+  // Daily
+  return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger>`;
+}
+
+/**
+ * Build a complete Task Scheduler XML definition.
+ */
+export function buildTaskXml(tr: string, triggers: string[]): string {
+  const [command, ...argParts] = tr.match(/"[^"]*"|[^\s]+/g) ?? [];
+  const commandStr = command?.replace(/"/g, "") ?? "";
+  const argsStr = argParts.map((a) => a.replace(/"/g, "")).join(" ");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-16"?>`,
+    `<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">`,
+    `  <Settings>`,
+    `    <MultipleInstancesPolicy>StopExisting</MultipleInstancesPolicy>`,
+    `    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>`,
+    `    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>`,
+    `    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>`,
+    `  </Settings>`,
+    `  <Triggers>${triggers.join("")}</Triggers>`,
+    `  <Actions>`,
+    `    <Exec>`,
+    `      <Command>${commandStr}</Command>`,
+    `      <Arguments>${argsStr}</Arguments>`,
+    `    </Exec>`,
+    `  </Actions>`,
+    `</Task>`,
+  ].join("\n");
 }
 
 function schtasksTaskName(taskId: string): string {
@@ -135,60 +158,38 @@ export class WindowsPlatform implements PlatformService {
     const tn = schtasksTaskName(taskId);
     const tr = schtasksTr("run", taskId);
 
-    // Always create the scheduled task with a dummy trigger first.
-    // This ensures startTask (/run) works even when no triggers are configured.
+    // Build trigger XML elements
+    const triggerElements: string[] = [];
+    if (task.frontmatter.triggers_enabled) {
+      for (const trigger of task.frontmatter.triggers ?? []) {
+        try {
+          triggerElements.push(triggerToXml(trigger));
+        } catch (err) {
+          console.error(`Invalid trigger: ${err}`);
+        }
+      }
+    }
+    // Always include a dummy trigger so startTask (/run) works
+    if (triggerElements.length === 0) {
+      triggerElements.push(`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`);
+    }
+
+    // Write XML and register via schtasks — gives us full control over
+    // settings like MultipleInstancesPolicy that schtasks flags don't expose.
+    const xml = buildTaskXml(tr, triggerElements);
+    const xmlPath = path.join(CONFIG_DIR, `task-${taskId}.xml`);
     try {
+      // schtasks /xml requires UTF-16LE with BOM
+      const bom = Buffer.from([0xFF, 0xFE]);
+      fs.writeFileSync(xmlPath, Buffer.concat([bom, Buffer.from(xml, "utf16le")]));
       execFileSync("schtasks", [
-        "/create", "/tn", tn,
-        "/tr", tr,
-        "/sc", "ONCE", "/sd", "01/01/2000", "/st", "00:00",
-        "/f",
+        "/create", "/tn", tn, "/xml", xmlPath, "/f",
       ], { encoding: "utf-8", windowsHide: true });
     } catch (err: unknown) {
       const e = err as { stderr?: string };
       console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
-    }
-
-    // Overlay with real schedule triggers if enabled
-    if (!task.frontmatter.triggers_enabled) return;
-    const triggers = task.frontmatter.triggers || [];
-    for (const trigger of triggers) {
-      if (trigger.type === "cron") {
-        const schedArgs = cronToSchtasksArgs(trigger.value);
-        try {
-          execFileSync("schtasks", [
-            "/create", "/tn", tn,
-            "/tr", tr,
-            ...schedArgs,
-            "/f",
-          ], { encoding: "utf-8", windowsHide: true });
-        } catch (err: unknown) {
-          const e = err as { stderr?: string };
-          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);
-        try {
-          execFileSync("schtasks", [
-            "/create", "/tn", tn,
-            "/tr", tr,
-            "/sc", "ONCE", "/sd", sd, "/st", st,
-            "/f",
-          ], { encoding: "utf-8", windowsHide: true });
-        } catch (err: unknown) {
-          const e = err as { stderr?: string };
-          console.error(`Failed to create once task ${tn}: ${e.stderr || err}`);
-        }
-      }
+    } finally {
+      try { fs.unlinkSync(xmlPath); } catch { /* ignore */ }
     }
   }
 

package/src/task.ts

@@ -20,7 +20,7 @@ export function parseTaskFile(taskDir: string): ParsedTask {
 /**
  * Parse TASK.md content string into frontmatter + body.
  */
-function parseTaskContent(content: string): ParsedTask {
+export function parseTaskContent(content: string): ParsedTask {
   const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
   const match = content.match(fmRegex);
 

package/test/agent-output-parsing.test.ts

@@ -0,0 +1,74 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseTaskOutcome, parseReportFiles, parsePermissions, parseInputRequests } from "../src/commands/run.js";
+
+describe("parseTaskOutcome", () => {
+  it("returns 'finished' for success marker", () => {
+    assert.equal(parseTaskOutcome("some output\n[PALMIER_TASK_SUCCESS]"), "finished");
+  });
+
+  it("returns 'failed' for failure marker", () => {
+    assert.equal(parseTaskOutcome("some output\n[PALMIER_TASK_FAILURE]"), "failed");
+  });
+
+  it("returns 'finished' when no marker is present", () => {
+    assert.equal(parseTaskOutcome("just some regular output"), "finished");
+  });
+
+  it("returns 'failed' when both markers present (failure takes priority)", () => {
+    assert.equal(parseTaskOutcome("[PALMIER_TASK_SUCCESS]\n[PALMIER_TASK_FAILURE]"), "failed");
+  });
+
+  it("only looks at last 500 chars", () => {
+    const padding = "x".repeat(600);
+    assert.equal(parseTaskOutcome("[PALMIER_TASK_FAILURE]" + padding), "finished");
+  });
+});
+
+describe("parseReportFiles", () => {
+  it("extracts report file names", () => {
+    const output = "doing work\n[PALMIER_REPORT] report.md\nmore work\n[PALMIER_REPORT] summary.md";
+    assert.deepEqual(parseReportFiles(output), ["report.md", "summary.md"]);
+  });
+
+  it("returns empty array when no reports", () => {
+    assert.deepEqual(parseReportFiles("no reports here"), []);
+  });
+
+  it("trims whitespace from file names", () => {
+    assert.deepEqual(parseReportFiles("[PALMIER_REPORT]   report.md  "), ["report.md"]);
+  });
+});
+
+describe("parsePermissions", () => {
+  it("extracts permissions with name and description", () => {
+    const output = "[PALMIER_PERMISSION] Read | Read file contents\n[PALMIER_PERMISSION] Bash(npm test) | Run tests";
+    const perms = parsePermissions(output);
+    assert.equal(perms.length, 2);
+    assert.deepEqual(perms[0], { name: "Read", description: "Read file contents" });
+    assert.deepEqual(perms[1], { name: "Bash(npm test)", description: "Run tests" });
+  });
+
+  it("handles permission without description", () => {
+    const perms = parsePermissions("[PALMIER_PERMISSION] Write");
+    assert.deepEqual(perms, [{ name: "Write", description: "" }]);
+  });
+
+  it("returns empty array when no permissions", () => {
+    assert.deepEqual(parsePermissions("no permissions"), []);
+  });
+});
+
+describe("parseInputRequests", () => {
+  it("extracts input descriptions", () => {
+    const output = "[PALMIER_INPUT] What is the API key?\n[PALMIER_INPUT] Database connection string?";
+    assert.deepEqual(parseInputRequests(output), [
+      "What is the API key?",
+      "Database connection string?",
+    ]);
+  });
+
+  it("returns empty array when no inputs", () => {
+    assert.deepEqual(parseInputRequests("no inputs"), []);
+  });
+});

package/test/linux-cron.test.ts

@@ -0,0 +1,41 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { cronToOnCalendar } from "../src/platform/linux.js";
+
+describe("cronToOnCalendar", () => {
+  it("converts hourly cron", () => {
+    assert.equal(cronToOnCalendar("0 * * * *"), "*-*-* *:00:00");
+  });
+
+  it("converts daily cron", () => {
+    assert.equal(cronToOnCalendar("30 9 * * *"), "*-*-* 09:30:00");
+  });
+
+  it("converts weekly Monday cron", () => {
+    assert.equal(cronToOnCalendar("0 10 * * 1"), "Mon *-*-* 10:00:00");
+  });
+
+  it("converts weekly Sunday (day 0)", () => {
+    assert.equal(cronToOnCalendar("0 8 * * 0"), "Sun *-*-* 08:00:00");
+  });
+
+  it("converts weekly Sunday (day 7)", () => {
+    assert.equal(cronToOnCalendar("0 8 * * 7"), "Sun *-*-* 08:00:00");
+  });
+
+  it("converts monthly cron", () => {
+    assert.equal(cronToOnCalendar("0 14 15 * *"), "*-*-15 14:00:00");
+  });
+
+  it("pads single-digit hours and minutes", () => {
+    assert.equal(cronToOnCalendar("5 3 * * *"), "*-*-* 03:05:00");
+  });
+
+  it("throws on invalid cron expression", () => {
+    assert.throws(() => cronToOnCalendar("bad"), /Invalid cron/);
+  });
+
+  it("throws on too few fields", () => {
+    assert.throws(() => cronToOnCalendar("0 * *"), /Invalid cron/);
+  });
+});

package/test/pairing.test.ts

@@ -0,0 +1,35 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { generatePairingCode, PAIRING_EXPIRY_MS } from "../src/commands/pair.js";
+
+describe("generatePairingCode", () => {
+  it("generates a 6-character code", () => {
+    const code = generatePairingCode();
+    assert.equal(code.length, 6);
+  });
+
+  it("only contains allowed characters (no O/0/I/1/L)", () => {
+    const allowed = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+    for (let i = 0; i < 50; i++) {
+      const code = generatePairingCode();
+      for (const ch of code) {
+        assert.ok(allowed.includes(ch), `Character '${ch}' is not in allowed set`);
+      }
+    }
+  });
+
+  it("generates unique codes", () => {
+    const codes = new Set<string>();
+    for (let i = 0; i < 100; i++) {
+      codes.add(generatePairingCode());
+    }
+    // With 30^6 ≈ 729M possibilities, 100 codes should all be unique
+    assert.equal(codes.size, 100);
+  });
+});
+
+describe("PAIRING_EXPIRY_MS", () => {
+  it("is 5 minutes", () => {
+    assert.equal(PAIRING_EXPIRY_MS, 5 * 60 * 1000);
+  });
+});

package/test/task-parsing.test.ts

@@ -0,0 +1,83 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseTaskContent } from "../src/task.js";
+
+describe("parseTaskContent", () => {
+  it("parses valid frontmatter and body", () => {
+    const content = `---
+id: abc123
+name: Test Task
+user_prompt: Do something
+agent: claude
+triggers: []
+triggers_enabled: true
+requires_confirmation: false
+---
+This is the task body.`;
+
+    const result = parseTaskContent(content);
+    assert.equal(result.frontmatter.id, "abc123");
+    assert.equal(result.frontmatter.name, "Test Task");
+    assert.equal(result.frontmatter.agent, "claude");
+    assert.equal(result.body, "This is the task body.");
+  });
+
+  it("defaults agent to claude when not specified", () => {
+    const content = `---
+id: abc123
+user_prompt: Do something
+triggers: []
+triggers_enabled: true
+requires_confirmation: false
+---`;
+
+    const result = parseTaskContent(content);
+    assert.equal(result.frontmatter.agent, "claude");
+  });
+
+  it("defaults triggers_enabled to true", () => {
+    const content = `---
+id: abc123
+user_prompt: Do something
+triggers: []
+requires_confirmation: false
+---`;
+
+    const result = parseTaskContent(content);
+    assert.equal(result.frontmatter.triggers_enabled, true);
+  });
+
+  it("derives name from user_prompt when not specified", () => {
+    const content = `---
+id: abc123
+user_prompt: A very long prompt that should be truncated to sixty characters maximum length here
+triggers: []
+triggers_enabled: true
+requires_confirmation: false
+---`;
+
+    const result = parseTaskContent(content);
+    assert.equal(result.frontmatter.name.length, 60);
+  });
+
+  it("throws on missing frontmatter delimiters", () => {
+    assert.throws(() => parseTaskContent("no frontmatter here"), /missing valid YAML/);
+  });
+
+  it("throws on missing id", () => {
+    assert.throws(() => parseTaskContent("---\nname: test\n---\n"), /must include at least: id/);
+  });
+
+  it("handles empty body", () => {
+    const content = `---
+id: abc123
+user_prompt: test
+triggers: []
+triggers_enabled: true
+requires_confirmation: false
+---`;
+
+    const result = parseTaskContent(content);
+    assert.equal(result.body, "");
+  });
+});

package/test/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "..",
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["./**/*", "../src/**/*"]
+}

package/test/windows-xml.test.ts

@@ -0,0 +1,88 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { triggerToXml, buildTaskXml } from "../src/platform/windows.js";
+
+describe("triggerToXml", () => {
+  it("converts a once trigger to TimeTrigger", () => {
+    const xml = triggerToXml({ type: "once", value: "2026-03-28T09:00" });
+    assert.equal(xml, "<TimeTrigger><StartBoundary>2026-03-28T09:00:00</StartBoundary></TimeTrigger>");
+  });
+
+  it("converts hourly cron to TimeTrigger with PT1H repetition", () => {
+    const xml = triggerToXml({ type: "cron", value: "0 * * * *" });
+    assert.ok(xml.includes("<Interval>PT1H</Interval>"), "should have hourly interval");
+    assert.ok(xml.includes("<TimeTrigger>"), "should be a TimeTrigger");
+  });
+
+  it("converts daily cron to CalendarTrigger with DaysInterval", () => {
+    const xml = triggerToXml({ type: "cron", value: "30 9 * * *" });
+    assert.ok(xml.includes("<ScheduleByDay>"), "should use ScheduleByDay");
+    assert.ok(xml.includes("<DaysInterval>1</DaysInterval>"), "should have interval 1");
+    assert.ok(xml.includes("T09:30:00"), "should encode time as 09:30");
+  });
+
+  it("converts weekly cron to CalendarTrigger with DaysOfWeek", () => {
+    const xml = triggerToXml({ type: "cron", value: "0 10 * * 1" });
+    assert.ok(xml.includes("<ScheduleByWeek>"), "should use ScheduleByWeek");
+    assert.ok(xml.includes("<Monday />"), "day 1 should be Monday");
+    assert.ok(xml.includes("T10:00:00"), "should encode time as 10:00");
+  });
+
+  it("converts weekly cron for Sunday (day 0)", () => {
+    const xml = triggerToXml({ type: "cron", value: "0 8 * * 0" });
+    assert.ok(xml.includes("<Sunday />"), "day 0 should be Sunday");
+  });
+
+  it("converts weekly cron for Sunday (day 7)", () => {
+    const xml = triggerToXml({ type: "cron", value: "0 8 * * 7" });
+    assert.ok(xml.includes("<Sunday />"), "day 7 should also be Sunday");
+  });
+
+  it("converts monthly cron to CalendarTrigger with DaysOfMonth", () => {
+    const xml = triggerToXml({ type: "cron", value: "0 14 15 * *" });
+    assert.ok(xml.includes("<ScheduleByMonth>"), "should use ScheduleByMonth");
+    assert.ok(xml.includes("<Day>15</Day>"), "should have day 15");
+    assert.ok(xml.includes("T14:00:00"), "should encode time as 14:00");
+    // All months should be listed
+    assert.ok(xml.includes("<January />"), "should include January");
+    assert.ok(xml.includes("<December />"), "should include December");
+  });
+
+  it("throws on invalid cron expression", () => {
+    assert.throws(() => triggerToXml({ type: "cron", value: "bad" }), /Invalid cron/);
+  });
+});
+
+describe("buildTaskXml", () => {
+  it("produces valid XML structure with StopExisting policy", () => {
+    const tr = '"C:\\Program Files\\nodejs\\node.exe" "C:\\palmier\\dist\\index.js" run abc123';
+    const triggers = ['<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>'];
+    const xml = buildTaskXml(tr, triggers);
+
+    assert.ok(xml.includes('<?xml version="1.0" encoding="UTF-16"?>'), "should have XML declaration");
+    assert.ok(xml.includes("<MultipleInstancesPolicy>StopExisting</MultipleInstancesPolicy>"), "should set StopExisting");
+    assert.ok(xml.includes("<DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>"), "should allow on battery");
+    assert.ok(xml.includes("<Command>C:\\Program Files\\nodejs\\node.exe</Command>"), "should extract command");
+    assert.ok(xml.includes("<Arguments>C:\\palmier\\dist\\index.js run abc123</Arguments>"), "should extract arguments");
+  });
+
+  it("handles multiple triggers", () => {
+    const tr = '"node" "palmier" run test';
+    const triggers = [
+      '<TimeTrigger><StartBoundary>2000-01-01T09:00:00</StartBoundary></TimeTrigger>',
+      '<CalendarTrigger><StartBoundary>2000-01-01T14:00:00</StartBoundary></CalendarTrigger>',
+    ];
+    const xml = buildTaskXml(tr, triggers);
+
+    assert.ok(xml.includes("<Triggers><TimeTrigger>"), "should contain first trigger");
+    assert.ok(xml.includes("</TimeTrigger><CalendarTrigger>"), "triggers should be concatenated");
+  });
+
+  it("parses command with spaces in path", () => {
+    const tr = '"C:\\Program Files\\nodejs\\node.exe" "C:\\My Folder\\script.js" serve';
+    const xml = buildTaskXml(tr, []);
+
+    assert.ok(xml.includes("<Command>C:\\Program Files\\nodejs\\node.exe</Command>"));
+    assert.ok(xml.includes("<Arguments>C:\\My Folder\\script.js serve</Arguments>"));
+  });
+});