palmier 0.4.3 → 0.4.4

package/README.md

@@ -127,11 +127,11 @@ palmier restart
 - **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional schedules (cron schedules or one-time dates).
 - **Plan generation** is automatic — when you create or update a task, the host invokes your chosen agent CLI to generate an execution plan and name.
 - **Schedules** are backed by systemd timers (Linux) or Task Scheduler (Windows). You can enable/disable them without deleting the task, and any task can still be run manually at any time.
-- **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
+- **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. On Windows, tasks run via a VBS wrapper (`wscript.exe`) to avoid visible console windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
 - **Command-triggered tasks** — optionally specify a shell command (e.g., `tail -f /var/log/app.log`). Palmier runs the command continuously and invokes the agent for each line of stdout, passing it alongside your prompt. Useful for log monitoring, event-driven automation, and reactive workflows.
 - **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (server mode) or a prompt in the PWA to confirm or abort.
-- **Run history** — each run produces a timestamped result file. You can view results and reports from the PWA.
-- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (LAN mode).
+- **Conversational run history** — each run produces a timestamped `RESULT-{ts}.md` file with a conversational structure: a sequence of assistant messages (agent output), user messages (input responses, permission grants, confirmations), and status entries (started, finished, failed, aborted). Timing and outcome are derived from status messages — no redundant frontmatter. The PWA displays these as a chat-like thread. Reports are attached per-message.
+- **Real-time updates** — task status changes and result updates are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (LAN mode). The run detail view live-updates as the agent produces output.
 - **Agent CLI commands** — `palmier notify` and `palmier request-input` allow agents to send push notifications and request user input during task execution without requiring MCP support.
 
 ## NATS Subjects
@@ -159,6 +159,8 @@ src/
   events.ts           # Event broadcasting (NATS pub/sub or HTTP SSE)
   agents/
     agent.ts          # AgentTool interface, registry, and agent detection
+    shared-prompt.ts  # Agent instructions loader
+    agent-instructions.md  # System prompt injected into every agent invocation
     claude.ts         # Claude Code agent implementation
     gemini.ts         # Gemini CLI agent implementation
     codex.ts          # Codex CLI agent implementation

package/dist/commands/request-input.d.ts

@@ -2,8 +2,7 @@
  * Request input from the user and print responses to stdout.
  * Usage: palmier request-input --description "Question 1" --description "Question 2"
  *
- * Requires PALMIER_TASK_ID environment variable to be set.
- * Outputs each response on its own line: "description: value"
+ * Requires PALMIER_TASK_ID and PALMIER_RUN_DIR environment variables.
  */
 export declare function requestInputCommand(opts: {
     description: string[];

package/dist/commands/request-input.js

@@ -1,13 +1,12 @@
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { getTaskDir, parseTaskFile, appendResultMessage } from "../task.js";
+import { getTaskDir, parseTaskFile, appendRunMessage } from "../task.js";
 import { requestUserInput, publishInputResolved } from "../user-input.js";
 /**
  * Request input from the user and print responses to stdout.
  * Usage: palmier request-input --description "Question 1" --description "Question 2"
  *
- * Requires PALMIER_TASK_ID environment variable to be set.
- * Outputs each response on its own line: "description: value"
+ * Requires PALMIER_TASK_ID and PALMIER_RUN_DIR environment variables.
  */
 export async function requestInputCommand(opts) {
     const taskId = process.env.PALMIER_TASK_ID;
@@ -19,33 +18,20 @@ export async function requestInputCommand(opts) {
     const nc = await connectNats(config);
     const taskDir = getTaskDir(config.projectRoot, taskId);
     const task = parseTaskFile(taskDir);
+    const runId = process.env.PALMIER_RUN_DIR?.split(/[/\\]/).pop();
     try {
         const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, opts.description);
         await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
         if (response === "aborted") {
-            // Write abort as user message if RESULT file is available
-            const resultFile = process.env.PALMIER_RESULT_FILE;
-            if (resultFile) {
-                appendResultMessage(taskDir, resultFile, {
-                    role: "user",
-                    time: Date.now(),
-                    content: "Input request aborted.",
-                    type: "input",
-                });
+            if (runId) {
+                appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Input request aborted.", type: "input" });
             }
             console.error("User aborted the input request.");
             process.exit(1);
         }
-        // Write user input as a conversation message
-        const resultFile = process.env.PALMIER_RESULT_FILE;
-        if (resultFile) {
+        if (runId) {
             const lines = opts.description.map((desc, i) => `**${desc}** ${response[i]}`);
-            appendResultMessage(taskDir, resultFile, {
-                role: "user",
-                time: Date.now(),
-                content: lines.join("\n"),
-                type: "input",
-            });
+            appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: lines.join("\n"), type: "input" });
         }
         for (let i = 0; i < opts.description.length; i++) {
             console.log(response[i]);

package/dist/commands/run.d.ts

@@ -1,4 +1,8 @@
 import type { TaskRunningState, RequiredPermission } from "../types.js";
+/**
+ * Strip [PALMIER_*] marker lines from agent output.
+ */
+export declare function stripPalmierMarkers(output: string): string;
 /**
  * Execute a task by ID.
  */

package/dist/commands/run.js

@@ -4,7 +4,7 @@ import * as readline from "readline";
 import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile, appendResultMessage, finalizeResultFrontmatter } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
@@ -23,8 +23,8 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
     while (true) {
         const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
         const result = await spawnCommand(command, args, {
-            cwd: ctx.taskDir,
-            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RESULT_FILE: ctx.resultFileName },
+            cwd: getRunDir(ctx.taskDir, ctx.runId),
+            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
             echoStdout: true,
             resolveOnFailure: true,
             stdin,
@@ -79,27 +79,29 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
 /**
  * Strip [PALMIER_*] marker lines from agent output.
  */
-function stripPalmierMarkers(output) {
+export function stripPalmierMarkers(output) {
     return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
 }
 /**
  * Append a conversation message to the RESULT file and notify connected clients.
  */
 async function appendAndNotify(ctx, msg) {
-    appendResultMessage(ctx.taskDir, ctx.resultFileName, msg);
-    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated" });
+    appendRunMessage(ctx.taskDir, ctx.runId, msg);
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
 /**
- * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ * Find the latest run dir that has no status messages yet (just created by the RPC handler).
  */
-function findStartedResultFile(taskDir) {
-    const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
-        if (content.includes("running_state: started"))
-            return file;
-    }
-    return null;
+function findLatestPendingRunId(taskDir) {
+    const dirs = fs.readdirSync(taskDir)
+        .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+        .sort();
+    if (dirs.length === 0)
+        return null;
+    const latest = dirs[dirs.length - 1];
+    const messages = readRunMessages(taskDir, latest);
+    const hasStatus = messages.some((m) => m.role === "status");
+    return hasStatus ? null : latest;
 }
 /**
  * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
@@ -121,30 +123,22 @@ export async function runCommand(taskId) {
     console.log(`Running task: ${taskId}`);
     let nc;
     const taskName = task.frontmatter.name;
-    // Check for an existing "started" result file (created by the RPC handler)
-    const existingResult = findStartedResultFile(taskDir);
-    const startTime = existingResult ? parseInt(existingResult.replace("RESULT-", "").replace(".md", ""), 10) : Date.now();
-    const resultFileName = existingResult ?? createResultFile(taskDir, taskName, startTime);
-    // Snapshot the task file at run time
-    const taskSnapshotName = `TASK-${startTime}.md`;
-    if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
-        fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    // Use existing run dir if just created by RPC, otherwise create a new one
+    const existingRunId = findLatestPendingRunId(taskDir);
+    const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now());
+    if (!existingRunId) {
+        appendHistory(config.projectRoot, { task_id: taskId, run_id: runId });
     }
     const cleanup = async () => {
         if (nc && !nc.isClosed()) {
             await nc.drain();
         }
     };
-    if (!existingResult) {
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    }
     try {
         nc = await connectNats(config);
-        // Mark as started immediately
-        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
-        // Status: started
-        appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "started" });
-        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, runId);
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "started" });
+        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(nc, config, task, taskDir);
@@ -152,30 +146,28 @@ export async function runCommand(taskId) {
             await publishConfirmResolved(nc, config, taskId, resolvedStatus);
             if (!confirmed) {
                 console.log("Task aborted by user.");
-                appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "aborted" });
-                finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: "aborted" });
-                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
+                appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
+                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, runId);
                 await cleanup();
                 return;
             }
             console.log("Task confirmed by user.");
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "confirmation" });
-            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "confirmation" });
+            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         }
         // Shared invocation context
         const guiEnv = getPlatform().getGuiEnv();
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
-            agent, task, taskDir, resultFileName, guiEnv, nc, config, taskId,
+            agent, task, taskDir, runId, guiEnv, nc, config, taskId,
             transientPermissions: [],
         };
         if (task.frontmatter.command) {
             // Command-triggered mode
             const result = await runCommandTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-            finalizeResultFrontmatter(taskDir, resultFileName, { end_time: result.endTime, running_state: outcome });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed (command-triggered).`);
         }
         else {
@@ -187,9 +179,8 @@ export async function runCommand(taskId) {
             });
             const result = await invokeAgentWithRetry(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-            finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed.`);
         }
     }
@@ -197,14 +188,13 @@ export async function runCommand(taskId) {
         console.error(`Task ${taskId} failed:`, err);
         const outcome = resolveOutcome(taskDir, "failed");
         const errorMsg = err instanceof Error ? err.message : String(err);
-        appendResultMessage(taskDir, resultFileName, {
+        appendRunMessage(taskDir, runId, {
             role: "assistant",
             time: Date.now(),
             content: errorMsg,
         });
-        appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-        finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
         process.exitCode = 1;
     }
     finally {
@@ -226,8 +216,8 @@ async function runCommandTriggeredMode(ctx) {
     const commandStr = ctx.task.frontmatter.command;
     console.log(`[command-triggered] Spawning: ${commandStr}`);
     const child = spawnStreamingCommand(commandStr, {
-        cwd: ctx.taskDir,
-        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id },
+        cwd: getRunDir(ctx.taskDir, ctx.runId),
+        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
     });
     let linesProcessed = 0;
     let invocationsSucceeded = 0;
@@ -236,7 +226,7 @@ async function runCommandTriggeredMode(ctx) {
     let processing = false;
     let commandExited = false;
     let resolveWhenDone;
-    const logPath = path.join(ctx.taskDir, "command-output.log");
+    const logPath = path.join(getRunDir(ctx.taskDir, ctx.runId), "command-output.log");
     function appendLog(line, agentOutput, outcome) {
         const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
         fs.appendFileSync(logPath, entry, "utf-8");
@@ -330,7 +320,7 @@ async function runCommandTriggeredMode(ctx) {
     const endTime = Date.now();
     return { outcome: "finished", endTime };
 }
-async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, resultFile) {
+async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
@@ -339,8 +329,8 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
         payload.name = taskName;
-    if (resultFile)
-        payload.result_file = resultFile;
+    if (runId)
+        payload.run_id = runId;
     await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 /**

package/dist/commands/serve.js

@@ -4,7 +4,7 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { createRpcHandler } from "../rpc-handler.js";
 import { startNatsTransport } from "../transports/nats-transport.js";
-import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile, appendResultMessage } from "../task.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
 import { detectAgents } from "../agents/agent.js";
@@ -13,38 +13,11 @@ import { CONFIG_DIR } from "../config.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
- * Mark a stuck task as failed: update status.json, write RESULT, append history,
- * and broadcast the failure event.
- */
-async function markTaskFailed(config, nc, taskId, reason) {
-    const taskDir = getTaskDir(config.projectRoot, taskId);
-    const status = readTaskStatus(taskDir);
-    if (!status || status.running_state !== "started")
-        return;
-    console.log(`[monitor] Task ${taskId} ${reason}, marking as failed.`);
-    const endTime = Date.now();
-    writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-    let taskName = taskId;
-    try {
-        const task = parseTaskFile(taskDir);
-        taskName = task.frontmatter.name || taskId;
-    }
-    catch { /* use taskId as fallback */ }
-    const resultFileName = `RESULT-${endTime}.md`;
-    const content = `---\ntask_name: ${taskName}\nrunning_state: failed\nstart_time: ${status.time_stamp}\nend_time: ${endTime}\ntask_file: \n---\n\n`;
-    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-    appendResultMessage(taskDir, resultFileName, {
-        role: "assistant",
-        time: endTime,
-        content: reason,
-    });
-    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    const payload = { event_type: "running-state", running_state: "failed", name: taskName };
-    await publishHostEvent(nc, config.hostId, taskId, payload);
-}
-/**
- * Scan all tasks for any stuck in "start" state whose process is no longer alive.
+ * Scan all tasks for any stuck in "started" state whose process is no longer alive.
  * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ *
+ * Since run.ts creates the RESULT file and history entry at start, we just need to
+ * finalize the existing RESULT file, append a failed status entry, and broadcast.
  */
 async function checkStaleTasks(config, nc) {
     const tasksJsonl = path.join(config.projectRoot, "tasks.jsonl");
@@ -67,7 +40,32 @@ async function checkStaleTasks(config, nc) {
         // Ask the system scheduler if the task is still running
         if (platform.isTaskRunning(taskId))
             continue;
-        await markTaskFailed(config, nc, taskId, "Task process exited unexpectedly");
+        console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
+        const endTime = Date.now();
+        writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
+        // Find the latest run directory (created by run.ts at start)
+        const runId = fs.readdirSync(taskDir)
+            .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+            .sort()
+            .pop();
+        if (runId) {
+            appendRunMessage(taskDir, runId, {
+                role: "status",
+                time: endTime,
+                content: "",
+                type: "failed",
+            });
+        }
+        let taskName = taskId;
+        try {
+            taskName = parseTaskFile(taskDir).frontmatter.name || taskId;
+        }
+        catch { /* use taskId as fallback */ }
+        await publishHostEvent(nc, config.hostId, taskId, {
+            event_type: "running-state",
+            running_state: "failed",
+            name: taskName,
+        });
     }
 }
 /**

package/dist/platform/linux.js

@@ -3,6 +3,8 @@ import * as path from "path";
 import { homedir } from "os";
 import { execSync, exec } from "child_process";
 import { promisify } from "util";
+import { loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 const execAsync = promisify(exec);
 const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
 const PATH_FILE = path.join(homedir(), ".config", "palmier", "user-path");
@@ -205,18 +207,26 @@ WantedBy=timers.target
         await execAsync(`systemctl --user stop ${serviceName}`);
     }
     isTaskRunning(taskId) {
+        // Check systemd first (for scheduled/on-demand runs)
         const serviceName = getServiceName(taskId);
         try {
-            // is-active exits 0 only for "active". For oneshot services (Type=oneshot),
-            // the state is "activating" while running, which exits non-zero.
-            // Use show -p ActiveState to reliably get the state without exit code issues.
             const out = execSync(`systemctl --user show -p ActiveState --value ${serviceName}`, { encoding: "utf-8" });
             const state = out.trim();
-            return state === "active" || state === "activating";
+            if (state === "active" || state === "activating")
+                return true;
         }
-        catch {
-            return false;
+        catch { /* service may not exist */ }
+        // Fall back to PID check (for follow-up runs spawned directly)
+        try {
+            const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+            const status = readTaskStatus(taskDir);
+            if (status?.pid) {
+                process.kill(status.pid, 0); // signal 0 = check if process exists
+                return true;
+            }
         }
+        catch { /* process not running or config unavailable */ }
+        return false;
     }
     getGuiEnv() {
         const uid = process.getuid?.();

package/dist/platform/windows.js

@@ -8,14 +8,6 @@ const TASK_PREFIX = "\\Palmier\\PalmierTask-";
 const DAEMON_TASK_NAME = "PalmierDaemon";
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 const DAEMON_VBS_FILE = path.join(CONFIG_DIR, "daemon.vbs");
-/**
- * Build the /tr value for schtasks: a single string with quoted paths
- * so Task Scheduler can invoke node with the palmier script + subcommand.
- */
-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 a cron expression or "once" trigger to Task Scheduler XML trigger elements.
@@ -144,7 +136,13 @@ export class WindowsPlatform {
     installTaskTimer(config, task) {
         const taskId = task.frontmatter.id;
         const tn = schtasksTaskName(taskId);
-        const tr = schtasksTr("run", taskId);
+        const script = process.argv[1] || "palmier";
+        // Write a VBS launcher so the task runs without a visible console window
+        const vbsPath = path.join(CONFIG_DIR, `task-${taskId}.vbs`);
+        const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" run ${taskId}", 0, True`;
+        fs.writeFileSync(vbsPath, vbs, "utf-8");
+        const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+        const tr = `"${wscript}" "${vbsPath}"`;
         // Build trigger XML elements
         const triggerElements = [];
         if (task.frontmatter.triggers_enabled) {
@@ -192,6 +190,10 @@ export class WindowsPlatform {
         catch {
             // Task might not exist — that's fine
         }
+        try {
+            fs.unlinkSync(path.join(CONFIG_DIR, `task-${taskId}.vbs`));
+        }
+        catch { /* ignore */ }
     }
     async startTask(taskId) {
         const tn = schtasksTaskName(taskId);
@@ -228,17 +230,40 @@ export class WindowsPlatform {
         }
     }
     isTaskRunning(taskId) {
+        // Check Task Scheduler first (for scheduled/on-demand runs)
         const tn = schtasksTaskName(taskId);
         try {
             const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
                 encoding: "utf-8",
                 windowsHide: true,
             });
-            return out.includes('"Running"');
+            if (out.includes('"Running"'))
+                return true;
         }
-        catch {
-            return false;
+        catch { /* task may not exist in scheduler */ }
+        // Fall back to PID check (for follow-up runs spawned directly, not via schtasks)
+        try {
+            const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+            const status = readTaskStatus(taskDir);
+            if (status?.pid) {
+                // tasklist exits 0 if the PID is found
+                execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/nh"], {
+                    encoding: "utf-8",
+                    windowsHide: true,
+                    stdio: "pipe",
+                });
+                // tasklist always exits 0; check if output contains 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() {
         // Windows GUI is always available — no special env vars needed