palmier 0.9.6 → 0.9.7

package/src/platform/macos.ts

@@ -1,329 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { homedir } from "os";
-import { execSync, exec } from "child_process";
-import { promisify } from "util";
-import type { PlatformService } from "./platform.js";
-import type { HostConfig, ParsedTask } from "../types.js";
-import { CONFIG_DIR, loadConfig } from "../config.js";
-import { getTaskDir, readTaskStatus } from "../task.js";
-
-const execAsync = promisify(exec);
-
-const AGENT_DIR = path.join(homedir(), "Library", "LaunchAgents");
-const PATH_FILE = path.join(CONFIG_DIR, "user-path");
-const DAEMON_LABEL = "me.palmier.host";
-const TASK_LABEL_PREFIX = "me.palmier.task.";
-
-function daemonPlistPath(): string {
-  return path.join(AGENT_DIR, `${DAEMON_LABEL}.plist`);
-}
-
-function taskLabel(taskId: string): string {
-  return `${TASK_LABEL_PREFIX}${taskId}`;
-}
-
-function taskPlistPath(taskId: string): string {
-  return path.join(AGENT_DIR, `${taskLabel(taskId)}.plist`);
-}
-
-function taskLogPath(taskId: string): string {
-  return path.join(CONFIG_DIR, `task-${taskId}.log`);
-}
-
-function guiDomain(): string {
-  const uid = process.getuid?.();
-  if (uid === undefined) throw new Error("getuid() unavailable — macOS platform requires POSIX uid");
-  return `gui/${uid}`;
-}
-
-/**
- * Convert one of the four PWA-produced cron patterns to a launchd
- * `StartCalendarInterval` dict.
- *   hourly  "0 * * * *"        → { Minute: 0 }
- *   daily   "MM HH * * *"      → { Minute, Hour }
- *   weekly  "MM HH * * D"      → { Minute, Hour, Weekday }
- *   monthly "MM HH D * *"      → { Minute, Hour, Day }
- * launchd Weekday: Sunday is 0 (cron 7 → 0).
- */
-export function cronToCalendarInterval(cron: string): Record<string, number> {
-  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;
-  const result: Record<string, number> = {};
-
-  if (minute !== "*") result.Minute = Number(minute);
-  if (hour !== "*") result.Hour = Number(hour);
-  if (dayOfMonth !== "*") result.Day = Number(dayOfMonth);
-  if (dayOfWeek !== "*") {
-    const dow = Number(dayOfWeek);
-    result.Weekday = dow === 7 ? 0 : dow;
-  }
-
-  for (const [k, v] of Object.entries(result)) {
-    if (!Number.isInteger(v) || v < 0) {
-      throw new Error(`Invalid cron field ${k}=${v} in ${cron}`);
-    }
-  }
-  return result;
-}
-
-/**
- * Convert a PWA `specific_times` value (ISO local datetime like "2026-04-20T09:00")
- * to a `StartCalendarInterval` dict. launchd has no "one-shot at date X" trigger,
- * so we omit Year — the task fires yearly on the same date and time. Sufficient
- * because the PWA regenerates/removes one-off tasks after they run.
- */
-export function specificTimeToCalendarInterval(iso: string): Record<string, number> {
-  const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/);
-  if (!m) throw new Error(`Invalid specific_times value: ${iso}`);
-  return {
-    Month: Number(m[2]),
-    Day: Number(m[3]),
-    Hour: Number(m[4]),
-    Minute: Number(m[5]),
-  };
-}
-
-function escapeXml(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/** Serialize a JS value to a plist XML fragment. Supports string/number/boolean/array/plain object. */
-function plistValue(value: unknown, indent: string): string {
-  if (typeof value === "string") return `${indent}<string>${escapeXml(value)}</string>`;
-  if (typeof value === "boolean") return `${indent}<${value ? "true" : "false"}/>`;
-  if (typeof value === "number") {
-    return Number.isInteger(value)
-      ? `${indent}<integer>${value}</integer>`
-      : `${indent}<real>${value}</real>`;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) return `${indent}<array/>`;
-    const inner = value.map((v) => plistValue(v, indent + "  ")).join("\n");
-    return `${indent}<array>\n${inner}\n${indent}</array>`;
-  }
-  if (value && typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>);
-    if (entries.length === 0) return `${indent}<dict/>`;
-    const inner = entries
-      .map(([k, v]) => `${indent}  <key>${escapeXml(k)}</key>\n${plistValue(v, indent + "  ")}`)
-      .join("\n");
-    return `${indent}<dict>\n${inner}\n${indent}</dict>`;
-  }
-  throw new Error(`Unsupported plist value type: ${typeof value}`);
-}
-
-export function buildPlist(dict: Record<string, unknown>): string {
-  return [
-    `<?xml version="1.0" encoding="UTF-8"?>`,
-    `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
-    `<plist version="1.0">`,
-    plistValue(dict, ""),
-    `</plist>`,
-    ``,
-  ].join("\n");
-}
-
-function runLaunchctl(args: string[], opts: { ignoreFailure?: boolean } = {}): void {
-  try {
-    execSync(`launchctl ${args.join(" ")}`, { stdio: "pipe", encoding: "utf-8" });
-  } catch (err: unknown) {
-    if (opts.ignoreFailure) return;
-    const e = err as { stderr?: string };
-    console.error(`launchctl ${args[0]} failed: ${e.stderr || err}`);
-  }
-}
-
-/**
- * Reload a LaunchAgent plist. The `enable` call is essential: after `bootout`
- * macOS can leave the service in a *disabled* state (tracked in
- * /var/db/com.apple.xpc.launchd/disabled.<uid>.plist). A subsequent bootstrap
- * then fails with "Bootstrap failed: 5: Input/output error".
- */
-function reloadAgent(domain: string, label: string, plistPath: string): void {
-  runLaunchctl(["bootout", `${domain}/${label}`], { ignoreFailure: true });
-  runLaunchctl(["enable", `${domain}/${label}`], { ignoreFailure: true });
-  runLaunchctl(["bootstrap", domain, `"${plistPath}"`]);
-}
-
-export class MacOsPlatform implements PlatformService {
-  installDaemon(config: HostConfig): void {
-    fs.mkdirSync(AGENT_DIR, { recursive: true });
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-
-    const palmierBin = process.argv[1] || "palmier";
-    const userPath = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
-    fs.writeFileSync(PATH_FILE, userPath, "utf-8");
-
-    const logPath = path.join(CONFIG_DIR, "daemon.log");
-    const plist = buildPlist({
-      Label: DAEMON_LABEL,
-      ProgramArguments: [process.execPath, palmierBin, "serve"],
-      WorkingDirectory: config.projectRoot,
-      RunAtLoad: true,
-      KeepAlive: { SuccessfulExit: false },
-      EnvironmentVariables: { PATH: userPath },
-      StandardOutPath: logPath,
-      StandardErrorPath: logPath,
-    });
-
-    const plistPath = daemonPlistPath();
-    fs.writeFileSync(plistPath, plist, "utf-8");
-    console.log("LaunchAgent installed at:", plistPath);
-
-    const domain = guiDomain();
-    reloadAgent(domain, DAEMON_LABEL, plistPath);
-    runLaunchctl(["kickstart", "-k", `${domain}/${DAEMON_LABEL}`]);
-
-    console.log("Palmier host LaunchAgent loaded and started.");
-    console.log(
-      "Note: LaunchAgents only run while you are logged into the GUI session. " +
-      "After reboot, tasks remain dormant until you log in at least once.",
-    );
-
-    console.log("\nHost initialization complete!");
-  }
-
-  uninstallDaemon(): void {
-    const domain = guiDomain();
-    runLaunchctl(["bootout", `${domain}/${DAEMON_LABEL}`], { ignoreFailure: true });
-    try { fs.unlinkSync(daemonPlistPath()); } catch { /* may not exist */ }
-
-    try {
-      const entries = fs.readdirSync(AGENT_DIR).filter((f) => f.startsWith(TASK_LABEL_PREFIX) && f.endsWith(".plist"));
-      for (const f of entries) {
-        const label = f.slice(0, -".plist".length);
-        runLaunchctl(["bootout", `${domain}/${label}`], { ignoreFailure: true });
-        try { fs.unlinkSync(path.join(AGENT_DIR, f)); } catch { /* ignore */ }
-      }
-    } catch { /* AGENT_DIR may not exist */ }
-
-    console.log("Palmier daemon and tasks uninstalled.");
-  }
-
-  async restartDaemon(): Promise<void> {
-    const plistPath = daemonPlistPath();
-    const domain = guiDomain();
-
-    if (process.stdin.isTTY && fs.existsSync(plistPath)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
-      const userPath = process.env.PATH || "";
-      fs.writeFileSync(PATH_FILE, userPath, "utf-8");
-
-      const content = fs.readFileSync(plistPath, "utf-8");
-      const updated = content.replace(
-        /(<key>PATH<\/key>\s*\n\s*<string>)[^<]*(<\/string>)/,
-        `$1${escapeXml(userPath)}$2`,
-      );
-      if (updated !== content) {
-        fs.writeFileSync(plistPath, updated, "utf-8");
-        reloadAgent(domain, DAEMON_LABEL, plistPath);
-      }
-    }
-
-    runLaunchctl(["kickstart", "-k", `${domain}/${DAEMON_LABEL}`]);
-    console.log("Palmier daemon restarted.");
-  }
-
-  installTaskTimer(config: HostConfig, task: ParsedTask): void {
-    fs.mkdirSync(AGENT_DIR, { recursive: true });
-
-    const taskId = task.frontmatter.id;
-    const label = taskLabel(taskId);
-    const plistPath = taskPlistPath(taskId);
-    const palmierBin = process.argv[1] || "palmier";
-
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    const logPath = taskLogPath(taskId);
-    const dict: Record<string, unknown> = {
-      Label: label,
-      ProgramArguments: [process.execPath, palmierBin, "run", taskId],
-      WorkingDirectory: config.projectRoot,
-      RunAtLoad: false,
-      EnvironmentVariables: { PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin" },
-      StandardOutPath: logPath,
-      StandardErrorPath: logPath,
-    };
-
-    const scheduleType = task.frontmatter.schedule_type;
-    const scheduleValues = task.frontmatter.schedule_values;
-    const isTimerSchedule = scheduleType === "crons" || scheduleType === "specific_times";
-    if (task.frontmatter.schedule_enabled && isTimerSchedule && scheduleValues?.length) {
-      const intervals: Record<string, number>[] = [];
-      for (const value of scheduleValues) {
-        try {
-          intervals.push(
-            scheduleType === "crons"
-              ? cronToCalendarInterval(value)
-              : specificTimeToCalendarInterval(value),
-          );
-        } catch (err) {
-          console.error(`Invalid schedule value: ${err}`);
-        }
-      }
-      if (intervals.length > 0) dict.StartCalendarInterval = intervals;
-    }
-
-    fs.writeFileSync(plistPath, buildPlist(dict), "utf-8");
-
-    const domain = guiDomain();
-    reloadAgent(domain, label, plistPath);
-  }
-
-  removeTaskTimer(taskId: string): void {
-    const domain = guiDomain();
-    runLaunchctl(["bootout", `${domain}/${taskLabel(taskId)}`], { ignoreFailure: true });
-    try { fs.unlinkSync(taskPlistPath(taskId)); } catch { /* ignore */ }
-    // Keep the log file — parity with journald retention on Linux, and
-    // needed to debug the last fire of one-shot specific_times tasks.
-  }
-
-  async startTask(taskId: string): Promise<void> {
-    await execAsync(`launchctl kickstart ${guiDomain()}/${taskLabel(taskId)}`);
-  }
-
-  async stopTask(taskId: string): Promise<void> {
-    try {
-      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
-      const status = readTaskStatus(taskDir);
-      if (status?.pid) {
-        process.kill(status.pid, "SIGTERM");
-        return;
-      }
-    } catch { /* fall through */ }
-
-    await execAsync(`launchctl kill SIGTERM ${guiDomain()}/${taskLabel(taskId)}`);
-  }
-
-  isTaskRunning(taskId: string): boolean {
-    try {
-      const out = execSync(`launchctl print ${guiDomain()}/${taskLabel(taskId)}`, {
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      // Running services show a numeric `pid = N`; idle ones show `state = not running`.
-      if (/^\s*pid\s*=\s*\d+/m.test(out)) return true;
-    } catch { /* service may not be loaded */ }
-
-    try {
-      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
-      const status = readTaskStatus(taskDir);
-      if (status?.pid) {
-        process.kill(status.pid, 0);
-        return true;
-      }
-    } catch { /* process not running or config unavailable */ }
-
-    return false;
-  }
-
-  getGuiEnv(): Record<string, string> {
-    return {};
-  }
-}

package/src/platform/platform.ts

@@ -1,31 +0,0 @@
-import type { HostConfig, ParsedTask } from "../types.js";
-
-/** Linux: systemd. Windows: Task Scheduler. macOS: launchd (planned). */
-export interface PlatformService {
-  /** Install the main `palmier serve` daemon to start at boot. */
-  installDaemon(config: HostConfig): void;
-
-  /** Restart the `palmier serve` daemon. */
-  restartDaemon(): Promise<void>;
-
-  /** Stop the daemon and remove all scheduled tasks/timers. */
-  uninstallDaemon(): 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>;
-
-  /** Check if a task is currently running via the system scheduler. */
-  isTaskRunning(taskId: string): boolean;
-
-  /** Return env vars needed for GUI access (Linux: DISPLAY, etc.). */
-  getGuiEnv(): Record<string, string>;
-}

package/src/platform/windows.ts

@@ -1,299 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { execFileSync } from "child_process";
-import type { PlatformService } from "./platform.js";
-import type { HostConfig, ParsedTask } from "../types.js";
-import { CONFIG_DIR, loadConfig } from "../config.js";
-import { getTaskDir, readTaskStatus } from "../task.js";
-
-
-const TASK_PREFIX = "\\Palmier\\PalmierTask-";
-const DAEMON_TASK_NAME = "PalmierDaemon";
-
-
-const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
-
-/**
- * Convert a single schedule value to a Task Scheduler XML trigger element.
- *
- * `specific_times` values are ISO datetime strings like "2026-03-28T09:00".
- *
- * `crons` values are cron expressions. Only these patterns (produced by the PWA UI) are handled:
- *   hourly:  "0 * * * *"
- *   daily:   "MM HH * * *"
- *   weekly:  "MM HH * * D"
- *   monthly: "MM HH D * *"
- */
-export function scheduleValueToXml(scheduleType: "crons" | "specific_times", value: string): string {
-  if (scheduleType === "specific_times") {
-    return `<TimeTrigger><StartBoundary>${value}:00</StartBoundary></TimeTrigger>`;
-  }
-
-  const parts = value.trim().split(/\s+/);
-  if (parts.length !== 5) throw new Error(`Invalid cron expression: ${value}`);
-  const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
-  const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
-  // StartBoundary needs a full date; anchor to a past one.
-  const base = `2000-01-01T${st}`;
-
-  if (hour === "*") {
-    return `<TimeTrigger><StartBoundary>${base}</StartBoundary><Repetition><Interval>PT1H</Interval></Repetition></TimeTrigger>`;
-  }
-
-  if (dayOfMonth === "*" && dayOfWeek !== "*") {
-    const day = DOW_NAMES[Number(dayOfWeek)] ?? "Monday";
-    return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByWeek><DaysOfWeek><${day} /></DaysOfWeek><WeeksInterval>1</WeeksInterval></ScheduleByWeek></CalendarTrigger>`;
-  }
-
-  if (dayOfMonth !== "*" && dayOfWeek === "*") {
-    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>`;
-  }
-
-  return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger>`;
-}
-
-export function buildTaskXml(tr: string, triggers: string[], foreground?: boolean): 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">`,
-    `  <Principals>`,
-    `    <Principal>`,
-    `      <LogonType>${foreground ? "InteractiveToken" : "S4U"}</LogonType>`,
-    `      <RunLevel>LeastPrivilege</RunLevel>`,
-    `    </Principal>`,
-    `  </Principals>`,
-    `  <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 {
-  return `${TASK_PREFIX}${taskId}`;
-}
-
-export class WindowsPlatform implements PlatformService {
-  installDaemon(config: HostConfig): void {
-    const script = process.argv[1] || "palmier";
-
-    this.ensureDaemonTask(script);
-    this.startDaemonTask();
-
-    console.log("\nHost initialization complete!");
-  }
-
-  uninstallDaemon(): void {
-    const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-
-    try {
-      execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-    } catch { /* task may not be running */ }
-
-    // Deleting an S4U task requires elevation.
-    try {
-      execFileSync("powershell", [
-        "-Command", `Start-Process -Verb RunAs -Wait -FilePath schtasks -ArgumentList '/delete /tn "${tn}" /f'`,
-      ], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-      console.log("Daemon task removed.");
-    } catch { /* task may not exist */ }
-
-    try {
-      const out = execFileSync("schtasks", ["/query", "/fo", "CSV", "/nh"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-      for (const line of out.split("\n")) {
-        const match = line.match(/"(\\Palmier\\PalmierTask-[^"]+)"/);
-        if (match) {
-          try { execFileSync("schtasks", ["/end", "/tn", match[1]], { encoding: "utf-8", windowsHide: true, stdio: "pipe" }); } catch { /* ignore */ }
-          try { execFileSync("schtasks", ["/delete", "/tn", match[1], "/f"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" }); } catch { /* ignore */ }
-        }
-      }
-      console.log("Task timers removed.");
-    } catch { /* ignore */ }
-
-    console.log("Palmier daemon and tasks uninstalled.");
-  }
-
-  async restartDaemon(): Promise<void> {
-    const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-
-    try {
-      execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-    } catch { /* task may not be running */ }
-
-    this.startDaemonTask();
-  }
-
-  /** S4U LogonType requires elevation to create. */
-  private ensureDaemonTask(script: string): void {
-    const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-    const tr = `"${process.execPath}" "${script}" serve`;
-    const xml = buildTaskXml(tr, [`<BootTrigger><Enabled>true</Enabled></BootTrigger>`]);
-    const xmlPath = path.join(CONFIG_DIR, "daemon-task.xml");
-    try {
-      const bom = Buffer.from([0xFF, 0xFE]);
-      fs.writeFileSync(xmlPath, Buffer.concat([bom, Buffer.from(xml, "utf16le")]));
-      // S4U requires elevation — spawn schtasks via RunAs.
-      const args = `/create /tn "${tn}" /xml "${xmlPath}" /f`;
-      execFileSync("powershell", [
-        "-Command", `Start-Process -Verb RunAs -Wait -FilePath schtasks -ArgumentList '${args}'`,
-      ], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-    } catch (err: unknown) {
-      const e = err as { stderr?: string };
-      console.error(`Failed to create daemon task: ${e.stderr || err}`);
-    } finally {
-      try { fs.unlinkSync(xmlPath); } catch { /* ignore */ }
-    }
-
-  }
-
-  /** Starting via Task Scheduler runs the daemon outside any session's job object. */
-  private startDaemonTask(): void {
-    const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-    try {
-      execFileSync("schtasks", ["/run", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
-    } catch (err: unknown) {
-      const e = err as { stderr?: string };
-      console.error(`Failed to start daemon via Task Scheduler: ${e.stderr || err}`);
-    }
-    console.log("Palmier daemon started.");
-  }
-
-  installTaskTimer(config: HostConfig, task: ParsedTask): void {
-    const taskId = task.frontmatter.id;
-    const tn = schtasksTaskName(taskId);
-    const script = process.argv[1] || "palmier";
-    const tr = `"${process.execPath}" "${script}" run ${taskId}`;
-
-    // Event-based schedule types (on_new_notification/on_new_sms) are driven by
-    // the run process, not the OS scheduler — they fall through to the dummy trigger.
-    const triggerElements: string[] = [];
-    const scheduleType = task.frontmatter.schedule_type;
-    const scheduleValues = task.frontmatter.schedule_values;
-    const isTimerSchedule = scheduleType === "crons" || scheduleType === "specific_times";
-    if (task.frontmatter.schedule_enabled && isTimerSchedule && scheduleValues?.length) {
-      for (const value of scheduleValues) {
-        try {
-          triggerElements.push(scheduleValueToXml(scheduleType, value));
-        } catch (err) {
-          console.error(`Invalid schedule value: ${err}`);
-        }
-      }
-    }
-    // Dummy trigger so schtasks /run still works.
-    if (triggerElements.length === 0) {
-      triggerElements.push(`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`);
-    }
-
-    // XML registration (vs schtasks flags) gives us access to settings like
-    // MultipleInstancesPolicy. S4U keeps the console hidden unless
-    // foreground_mode is set. Works unelevated because the caller (daemon)
-    // runs elevated.
-    const xml = buildTaskXml(tr, triggerElements, task.frontmatter.foreground_mode);
-    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, "/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}`);
-    } finally {
-      try { fs.unlinkSync(xmlPath); } catch { /* ignore */ }
-    }
-
-  }
-
-  removeTaskTimer(taskId: string): void {
-    const tn = schtasksTaskName(taskId);
-    try {
-      execFileSync("schtasks", ["/delete", "/tn", tn, "/f"], { encoding: "utf-8", windowsHide: true });
-    } catch { /* task may not exist */ }
-  }
-
-  async startTask(taskId: string): Promise<void> {
-    const tn = schtasksTaskName(taskId);
-    try {
-      execFileSync("schtasks", ["/run", "/tn", tn], { encoding: "utf-8", windowsHide: true });
-    } catch (err: unknown) {
-      const e = err as { stderr?: string; message?: string };
-      throw new Error(`Failed to start task via schtasks: ${e.stderr || e.message}`);
-    }
-  }
-
-  async stopTask(taskId: string): Promise<void> {
-    // schtasks /end leaves agent children orphaned, so kill the process tree
-    // via the PID recorded in status.json first.
-    try {
-      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
-      const status = readTaskStatus(taskDir);
-      if (status?.pid) {
-        execFileSync("taskkill", ["/pid", String(status.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
-        return;
-      }
-    } catch {
-      // PID may be stale or config unavailable; fall through to schtasks /end.
-    }
-
-    const tn = schtasksTaskName(taskId);
-    try {
-      execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
-    } catch (err: unknown) {
-      const e = err as { stderr?: string; message?: string };
-      throw new Error(`Failed to stop task via schtasks: ${e.stderr || e.message}`);
-    }
-  }
-
-  isTaskRunning(taskId: string): boolean {
-    const tn = schtasksTaskName(taskId);
-    try {
-      const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
-        encoding: "utf-8",
-        windowsHide: true,
-      });
-      if (out.includes('"Running"')) return true;
-    } catch { /* task may not exist in scheduler */ }
-
-    // Follow-up runs are spawned directly (not via schtasks), so check PID too.
-    try {
-      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
-      const status = readTaskStatus(taskDir);
-      if (status?.pid) {
-        execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/nh"], {
-          encoding: "utf-8",
-          windowsHide: true,
-          stdio: "pipe",
-        });
-        // tasklist always exits 0, so match the output for the PID.
-        const out = execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/fo", "CSV", "/nh"], {
-          encoding: "utf-8",
-          windowsHide: true,
-          stdio: "pipe",
-        });
-        if (out.includes(`"${status.pid}"`)) return true;
-      }
-    } catch { /* ignore */ }
-
-    return false;
-  }
-
-  getGuiEnv(): Record<string, string> {
-    return {};
-  }
-}