palmier 0.3.4 → 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/dist/agents/copilot.js

@@ -25,7 +25,7 @@ export class CopilotAgent {
     }
     async init() {
         try {
-            execSync("gh copilot -v", { stdio: "ignore", shell: SHELL });
+            execSync("copilot -v", { stdio: "ignore", shell: SHELL });
         }
         catch {
             return false;

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

@@ -25,7 +25,7 @@ const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Frid
  *   weekly:  "MM HH * * D"
  *   monthly: "MM HH D * *"
  */
-function triggerToXml(trigger) {
+export function triggerToXml(trigger) {
     if (trigger.type === "once") {
         // ISO datetime "2026-03-28T09:00"
         return `<TimeTrigger><StartBoundary>${trigger.value}:00</StartBoundary></TimeTrigger>`;
@@ -56,7 +56,7 @@ function triggerToXml(trigger) {
 /**
  * Build a complete Task Scheduler XML definition.
  */
-function buildTaskXml(tr, triggers) {
+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(" ");

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.4",
+  "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/copilot.ts

@@ -30,7 +30,7 @@ export class CopilotAgent implements AgentTool {
 
   async init(): Promise<boolean> {
     try {
-      execSync("gh copilot -v", { stdio: "ignore", shell: SHELL });
+      execSync("copilot -v", { stdio: "ignore", shell: SHELL });
     } catch {
       return false;
     }

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

@@ -32,7 +32,7 @@ const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Frid
  *   weekly:  "MM HH * * D"
  *   monthly: "MM HH D * *"
  */
-function triggerToXml(trigger: { type: string; value: string }): string {
+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>`;
@@ -68,7 +68,7 @@ function triggerToXml(trigger: { type: string; value: string }): string {
 /**
  * Build a complete Task Scheduler XML definition.
  */
-function buildTaskXml(tr: string, triggers: string[]): string {
+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(" ");

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>"));
+  });
+});