palmier 0.4.2 → 0.4.4

package/dist/commands/run.js

@@ -4,25 +4,12 @@ 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 } 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, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import { publishHostEvent } from "../events.js";
-import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
-/**
- * Write a time-stamped RESULT file with frontmatter.
- * Always generated, even for abort/fail.
- */
-/**
- * Update an existing result file with the final outcome.
- */
-function finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, runningState, startTime, endTime, output, reportFiles, requiredPermissions) {
-    const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
-    const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
-    const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
-    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-}
+import { waitForUserInput } from "../user-input.js";
 /**
  * Invoke the agent CLI with a retry loop for permissions and user input.
  *
@@ -36,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 },
+            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,
@@ -45,15 +32,35 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
         const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
         const reportFiles = parseReportFiles(result.output);
         const requiredPermissions = parsePermissions(result.output);
+        // Append assistant message for this invocation
+        await appendAndNotify(ctx, {
+            role: "assistant",
+            time: Date.now(),
+            content: stripPalmierMarkers(result.output),
+            attachments: reportFiles.length > 0 ? reportFiles : undefined,
+        });
         // Permission retry
         if (outcome === "failed" && requiredPermissions.length > 0) {
             const response = await requestPermission(ctx.nc, ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
             await publishPermissionResolved(ctx.nc, ctx.config, ctx.taskId, response);
             if (response === "aborted") {
-                return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
+                await appendAndNotify(ctx, {
+                    role: "user",
+                    time: Date.now(),
+                    content: "Permissions denied. Task aborted.",
+                    type: "permission",
+                });
+                return { outcome: "failed" };
             }
             const newPerms = requiredPermissions.filter((rp) => !ctx.task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
                 && !ctx.transientPermissions.some((ep) => ep.name === rp.name));
+            // Append user message for permission grant
+            await appendAndNotify(ctx, {
+                role: "user",
+                time: Date.now(),
+                content: `Permissions granted: ${newPerms.map((p) => p.name).join(", ")}`,
+                type: "permission",
+            });
             if (response === "granted_all") {
                 ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
                 invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
@@ -65,33 +72,36 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
             retryPrompt = "Permissions granted, please continue.";
             continue;
         }
-        // Input retry
-        const inputRequests = parseInputRequests(result.output);
-        if (outcome === "failed" && inputRequests.length > 0) {
-            const response = await requestUserInput(ctx.nc, ctx.config, ctx.taskId, ctx.task.frontmatter.name, ctx.taskDir, inputRequests);
-            await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided");
-            if (response === "aborted") {
-                return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
-            }
-            const inputLines = inputRequests.map((desc, i) => `- ${desc} → ${response[i]}`).join("\n");
-            retryPrompt = `The user provided the following inputs:\n${inputLines}\nPlease continue with these values.`;
-            continue;
-        }
         // Normal completion (success or non-retryable failure)
-        return { output: result.output, outcome, reportFiles, requiredPermissions };
+        return { outcome };
     }
 }
 /**
- * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ * Strip [PALMIER_*] marker lines from agent output.
  */
-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;
+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) {
+    appendRunMessage(ctx.taskDir, ctx.runId, msg);
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+}
+/**
+ * Find the latest run dir that has no status messages yet (just created by the RPC handler).
+ */
+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),
@@ -113,27 +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);
+        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);
@@ -141,54 +146,55 @@ export async function runCommand(taskId) {
             await publishConfirmResolved(nc, config, taskId, resolvedStatus);
             if (!confirmed) {
                 console.log("Task aborted by user.");
-                const endTime = Date.now();
-                finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-                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.");
+            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, 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);
-            finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
-            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 {
-            // Standard execution
+            // Standard execution — add user prompt as first message
+            await appendAndNotify(ctx, {
+                role: "user",
+                time: Date.now(),
+                content: task.body || task.frontmatter.user_prompt,
+            });
             const result = await invokeAgentWithRetry(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
-            if (result.reportFiles.length > 0) {
-                await publishHostEvent(nc, config.hostId, taskId, {
-                    event_type: "report-generated",
-                    name: taskName,
-                    report_files: result.reportFiles,
-                    running_state: outcome,
-                    result_file: 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.`);
         }
     }
     catch (err) {
         console.error(`Task ${taskId} failed:`, err);
-        const endTime = Date.now();
         const outcome = resolveOutcome(taskDir, "failed");
         const errorMsg = err instanceof Error ? err.message : String(err);
-        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+        appendRunMessage(taskDir, runId, {
+            role: "assistant",
+            time: Date.now(),
+            content: errorMsg,
+        });
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
         process.exitCode = 1;
     }
     finally {
@@ -210,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;
@@ -220,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");
@@ -256,7 +262,7 @@ async function runCommandTriggeredMode(ctx) {
         else {
             invocationsFailed++;
         }
-        appendLog(line, result.output, result.outcome);
+        appendLog(line, "", result.outcome);
     }
     async function drainQueue() {
         if (processing)
@@ -312,25 +318,19 @@ async function runCommandTriggeredMode(ctx) {
         });
     }
     const endTime = Date.now();
-    const summary = [
-        `Command: ${commandStr}`,
-        `Exit code: ${exitCode}`,
-        `Lines processed: ${linesProcessed}`,
-        `Agent invocations succeeded: ${invocationsSucceeded}`,
-        `Agent invocations failed: ${invocationsFailed}`,
-    ].join("\n");
-    return { outcome: "finished", endTime, output: summary };
+    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(),
+        ...(eventType === "started" ? { pid: process.pid } : {}),
     });
     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);
 }
 /**
@@ -417,21 +417,6 @@ export function parsePermissions(output) {
     }
     return perms;
 }
-/**
- * Extract user input requests from agent output.
- * Looks for lines matching: [PALMIER_INPUT] <description>
- */
-export function parseInputRequests(output) {
-    const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
-    const inputs = [];
-    let match;
-    while ((match = regex.exec(output)) !== null) {
-        const desc = match[1].trim();
-        if (desc)
-            inputs.push(desc);
-    }
-    return inputs;
-}
 /**
  * Parse the agent's output for success/failure markers.
  * Falls back to "finished" if no marker is found.

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 } 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,33 +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${reason}`;
-    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-    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");
@@ -62,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/index.js

@@ -8,7 +8,8 @@ import { initCommand } from "./commands/init.js";
 import { infoCommand } from "./commands/info.js";
 import { runCommand } from "./commands/run.js";
 import { serveCommand } from "./commands/serve.js";
-import { mcpserverCommand } from "./commands/mcpserver.js";
+import { notifyCommand } from "./commands/notify.js";
+import { requestInputCommand } from "./commands/request-input.js";
 import { pairCommand } from "./commands/pair.js";
 import { lanCommand } from "./commands/lan.js";
 import { restartCommand } from "./commands/restart.js";
@@ -51,10 +52,19 @@ program
     await restartCommand();
 });
 program
-    .command("mcpserver")
-    .description("Start an MCP server exposing Palmier tools (stdio transport)")
-    .action(async () => {
-    await mcpserverCommand();
+    .command("notify")
+    .description("Send a push notification to the user")
+    .requiredOption("--title <title>", "Notification title")
+    .requiredOption("--body <body>", "Notification body text")
+    .action(async (opts) => {
+    await notifyCommand(opts);
+});
+program
+    .command("request-input")
+    .description("Request input from the user (requires PALMIER_TASK_ID env var)")
+    .requiredOption("--description <desc...>", "Input descriptions to show the user")
+    .action(async (opts) => {
+    await requestInputCommand(opts);
 });
 program
     .command("pair")

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

@@ -2,19 +2,12 @@ import * as fs from "fs";
 import * as path from "path";
 import { execFileSync } from "child_process";
 import { spawn as nodeSpawn } from "child_process";
-import { CONFIG_DIR } from "../config.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 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.
@@ -118,7 +111,7 @@ export class WindowsPlatform {
         // Kill old daemon first, then spawn new one.
         if (oldPid) {
             try {
-                execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
+                execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
             }
             catch {
                 // Process may have already exited
@@ -143,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) {
@@ -191,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);
@@ -203,6 +206,20 @@ export class WindowsPlatform {
         }
     }
     async stopTask(taskId) {
+        // Try to kill the entire process tree via the PID recorded in status.json.
+        // schtasks /end only kills the top-level process, leaving agent children orphaned.
+        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
+        }
+        // Fallback: schtasks /end (kills top-level process only)
         const tn = schtasksTaskName(taskId);
         try {
             execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
@@ -213,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