palmier 0.4.9 → 0.5.1

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, createRunDir, appendRunMessage, readRunMessages, getRunDir } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir, beginStreamingMessage } 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";
@@ -19,6 +19,20 @@ import { publishHostEvent } from "../events.js";
 async function invokeAgentWithRetries(ctx, invokeTask) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
+        // Stream agent output to TASKRUN.md in real-time, throttled to 500ms
+        const writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now());
+        let lineBuf = "";
+        let notifyPending = false;
+        let notifyTimer;
+        function throttledNotify() {
+            if (notifyPending)
+                return;
+            notifyPending = true;
+            notifyTimer = setTimeout(() => {
+                notifyPending = false;
+                publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+            }, 500);
+        }
         const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.transientPermissions);
         const result = await spawnCommand(command, args, {
             cwd: getRunDir(ctx.taskDir, ctx.runId),
@@ -26,17 +40,33 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             echoStdout: true,
             resolveOnFailure: true,
             stdin,
+            onData: (chunk) => {
+                lineBuf += chunk;
+                const lines = lineBuf.split("\n");
+                lineBuf = lines.pop() ?? "";
+                const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
+                if (filtered.length > 0) {
+                    writer.write(filtered.join("\n") + "\n");
+                    throttledNotify();
+                }
+            },
         });
+        if (notifyTimer)
+            clearTimeout(notifyTimer);
         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,
-        });
+        // Flush remaining buffered content
+        if (lineBuf && !lineBuf.startsWith("[PALMIER")) {
+            writer.write(lineBuf);
+        }
+        // Include permission requests in the assistant message
+        if (requiredPermissions.length > 0) {
+            const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
+            writer.write(`\n\n**Permissions requested:**\n${permLines}\n`);
+        }
+        writer.end(reportFiles.length > 0 ? reportFiles : undefined);
+        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
         // Permission handling — agent requested permissions
         if (requiredPermissions.length > 0) {
             const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
@@ -44,18 +74,17 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
                 await appendAndNotify(ctx, {
                     role: "user",
                     time: Date.now(),
-                    content: "Permissions denied. Task aborted.",
+                    content: "Denied",
                     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(", ")}`,
+                content: response === "granted_all" ? "Granted for all" : "Granted",
                 type: "permission",
             });
             if (response === "granted_all") {
@@ -212,6 +241,8 @@ const MAX_LINE_LENGTH = 200_000;
 async function runCommandTriggeredMode(ctx) {
     const commandStr = ctx.task.frontmatter.command;
     console.log(`[command-triggered] Spawning: ${commandStr}`);
+    appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
     const child = spawnStreamingCommand(commandStr, {
         cwd: getRunDir(ctx.taskDir, ctx.runId),
         env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
@@ -341,7 +372,11 @@ async function requestPermission(config, task, taskDir, requiredPermissions) {
             permissions: requiredPermissions,
         }),
     });
-    const { response } = await res.json();
+    const body = await res.json();
+    const response = body.response;
+    if (!response || !["granted", "granted_all", "aborted"].includes(response)) {
+        throw new Error(`Permission request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+    }
     writeTaskStatus(taskDir, {
         running_state: response === "aborted" ? "aborted" : "started",
         time_stamp: Date.now(),
@@ -355,7 +390,11 @@ async function requestConfirmation(config, task, taskDir) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
     });
-    const { confirmed } = await res.json();
+    const body = await res.json();
+    if (typeof body.confirmed !== "boolean") {
+        throw new Error(`Confirmation request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+    }
+    const { confirmed } = body;
     writeTaskStatus(taskDir, {
         running_state: confirmed ? "started" : "aborted",
         time_stamp: Date.now(),

package/dist/commands/serve.js

@@ -82,7 +82,14 @@ export async function serveCommand() {
     config.agents = agents;
     saveConfig(config);
     console.log(`Detected agents: ${agents.map((a) => a.key).join(", ") || "none"}`);
-    const nc = await connectNats(config);
+    let nc;
+    try {
+        nc = await connectNats(config);
+        console.log("[nats] Connected");
+    }
+    catch (err) {
+        console.warn(`[nats] Connection failed (server mode unavailable): ${err}`);
+    }
     // Reconcile any tasks stuck from before daemon started
     await checkStaleTasks(config, nc);
     // Poll for crashed tasks every 30 seconds

package/dist/platform/windows.d.ts

@@ -20,7 +20,10 @@ export declare function buildTaskXml(tr: string, triggers: string[]): string;
 export declare class WindowsPlatform implements PlatformService {
     installDaemon(config: HostConfig): void;
     restartDaemon(): Promise<void>;
-    private spawnDaemon;
+    /** Create or update the Task Scheduler entry for the daemon. */
+    private ensureDaemonTask;
+    /** Start the daemon via Task Scheduler (runs outside any session's job object). */
+    private startDaemonTask;
     installTaskTimer(config: HostConfig, task: ParsedTask): void;
     removeTaskTimer(taskId: string): void;
     startTask(taskId: string): Promise<void>;

package/dist/platform/windows.js

@@ -1,7 +1,6 @@
 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, loadConfig } from "../config.js";
 import { getTaskDir, readTaskStatus } from "../task.js";
 const TASK_PREFIX = "\\Palmier\\PalmierTask-";
@@ -78,11 +77,11 @@ function schtasksTaskName(taskId) {
 export class WindowsPlatform {
     installDaemon(config) {
         const script = process.argv[1] || "palmier";
-        // Write a VBS launcher that starts the daemon with no visible console window.
-        // VBS doesn't use backslash escaping — only quotes need doubling ("").
-        const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
-        fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
-        const regValue = `"${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe" "${DAEMON_VBS_FILE}"`;
+        // Create the Task Scheduler entry for the daemon
+        this.ensureDaemonTask(script);
+        // Registry Run key triggers the Task Scheduler entry on logon,
+        // so the daemon always runs outside any session's job object.
+        const regValue = `schtasks /run /tn "\\Palmier\\${DAEMON_TASK_NAME}"`;
         try {
             execFileSync("reg", [
                 "add", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
@@ -95,20 +94,19 @@ export class WindowsPlatform {
             console.error("You may need to start palmier serve manually.");
         }
         // Start the daemon now
-        this.spawnDaemon(script);
+        this.startDaemonTask();
         console.log("\nHost initialization complete!");
     }
     async restartDaemon() {
-        const script = process.argv[1] || "palmier";
         const oldPid = fs.existsSync(DAEMON_PID_FILE)
             ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
             : null;
         if (oldPid && oldPid === String(process.pid)) {
             // We ARE the old daemon (auto-update) — spawn replacement then exit.
-            this.spawnDaemon(script);
+            this.startDaemonTask();
             process.exit(0);
         }
-        // Kill old daemon first, then spawn new one.
+        // Kill old daemon by PID
         if (oldPid) {
             try {
                 execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
@@ -117,21 +115,59 @@ export class WindowsPlatform {
                 // Process may have already exited
             }
         }
-        this.spawnDaemon(script);
+        // Also kill any stale palmier serve processes (e.g. leftover from a previous daemon)
+        try {
+            const out = execFileSync("wmic", ["process", "where", `CommandLine like '%palmier%serve%' and ProcessId != '${process.pid}'`, "get", "ProcessId"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
+            for (const line of out.split("\n")) {
+                const pid = line.trim();
+                if (pid && /^\d+$/.test(pid)) {
+                    try {
+                        execFileSync("taskkill", ["/pid", pid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch {
+            // wmic may not be available on all Windows versions
+        }
+        this.startDaemonTask();
     }
-    spawnDaemon(script) {
-        // Write a VBS launcher that starts the daemon with no visible console window.
+    /** Create or update the Task Scheduler entry for the daemon. */
+    ensureDaemonTask(script) {
         const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
         fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
-        // Use `cmd /c start` to break out of the SSH session's job object.
-        // Without this, the daemon is killed when the SSH session disconnects.
-        const child = nodeSpawn("cmd", ["/c", "start", "/b", "wscript.exe", DAEMON_VBS_FILE], {
-            detached: true,
-            stdio: "ignore",
-            windowsHide: true,
-        });
-        child.unref();
-        // PID file will be written by the serve command itself when it starts.
+        const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+        const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
+        const tr = `"${wscript}" "${DAEMON_VBS_FILE}"`;
+        const xml = buildTaskXml(tr, [`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`]);
+        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")]));
+            execFileSync("schtasks", ["/create", "/tn", tn, "/xml", xmlPath, "/f"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
+        }
+        catch (err) {
+            const e = err;
+            console.error(`Failed to create daemon task: ${e.stderr || err}`);
+        }
+        finally {
+            try {
+                fs.unlinkSync(xmlPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Start the daemon via Task Scheduler (runs outside any session's job object). */
+    startDaemonTask() {
+        const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
+        try {
+            execFileSync("schtasks", ["/run", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
+        }
+        catch (err) {
+            const e = err;
+            console.error(`Failed to start daemon via Task Scheduler: ${e.stderr || err}`);
+        }
         console.log("Palmier daemon started.");
     }
     installTaskTimer(config, task) {

package/dist/rpc-handler.js

@@ -39,8 +39,8 @@ function parseResultFrontmatter(raw) {
     const terminalMsg = [...statusMessages].reverse().find((m) => terminalStates.includes(m.type ?? ""));
     // If last status is "started", determine if it's a task run or follow-up
     let runningState;
-    if (lastStatus?.type === "started") {
-        runningState = terminalMsg ? "followup" : "started";
+    if (lastStatus?.type === "started" || lastStatus?.type === "monitoring") {
+        runningState = terminalMsg ? "followup" : (lastStatus?.type ?? "started");
     }
     else {
         runningState = lastStatus?.type;
@@ -126,10 +126,17 @@ const activeFollowups = new Map();
 export function createRpcHandler(config, nc) {
     function flattenTask(task) {
         const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
+        const status = readTaskStatus(taskDir);
+        const pending = getPending(task.frontmatter.id);
         return {
             ...task.frontmatter,
             body: task.body,
-            status: readTaskStatus(taskDir),
+            status: status ? {
+                ...status,
+                ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
+                ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
+                ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
+            } : undefined,
         };
     }
     async function handleRpc(request) {

package/dist/spawn-command.d.ts

@@ -29,6 +29,8 @@ export interface SpawnCommandOptions {
     resolveOnFailure?: boolean;
     /** If provided, write this string to the process's stdin and then close the pipe. */
     stdin?: string;
+    /** Called on each chunk of output (stdout + stderr combined). */
+    onData?: (chunk: string) => void;
 }
 /**
  * Spawn a command with additional arguments.

package/dist/spawn-command.js

@@ -57,10 +57,14 @@ export function spawnCommand(command, args, opts) {
             chunks.push(d);
             if (opts.echoStdout)
                 process.stdout.write(d);
+            if (opts.onData)
+                opts.onData(d.toString("utf-8"));
         });
         child.stderr.on("data", (d) => {
             chunks.push(d);
             process.stderr.write(d);
+            if (opts.onData)
+                opts.onData(d.toString("utf-8"));
         });
         let timer;
         if (opts.timeout) {

package/dist/task.d.ts

@@ -51,6 +51,20 @@ export declare function getRunDir(taskDir: string, runId: string): string;
  * Append a conversation message to a run's TASKRUN.md file.
  */
 export declare function appendRunMessage(taskDir: string, runId: string, msg: ConversationMessage): void;
+/**
+ * Begin a streaming assistant message — writes the delimiter only.
+ * Returns a writer that appends content chunks and finalizes the message.
+ */
+export declare function beginStreamingMessage(taskDir: string, runId: string, time: number): StreamingMessageWriter;
+export declare class StreamingMessageWriter {
+    private filePath;
+    private delimiter;
+    constructor(filePath: string, delimiter: string);
+    /** Append a chunk of content to the current message. */
+    write(chunk: string): void;
+    /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+    end(attachments?: string[]): void;
+}
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

package/dist/task.js

@@ -161,6 +161,37 @@ export function appendRunMessage(taskDir, runId, msg) {
     const entry = `${delimiter}\n\n${msg.content}\n\n`;
     fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
 }
+/**
+ * Begin a streaming assistant message — writes the delimiter only.
+ * Returns a writer that appends content chunks and finalizes the message.
+ */
+export function beginStreamingMessage(taskDir, runId, time) {
+    const filePath = path.join(taskDir, runId, "TASKRUN.md");
+    const delimiter = `<!-- palmier:message role="assistant" time="${time}" -->`;
+    fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
+    return new StreamingMessageWriter(filePath, delimiter);
+}
+export class StreamingMessageWriter {
+    filePath;
+    delimiter;
+    constructor(filePath, delimiter) {
+        this.filePath = filePath;
+        this.delimiter = delimiter;
+    }
+    /** Append a chunk of content to the current message. */
+    write(chunk) {
+        fs.appendFileSync(this.filePath, chunk, "utf-8");
+    }
+    /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+    end(attachments) {
+        fs.appendFileSync(this.filePath, "\n\n", "utf-8");
+        if (attachments?.length) {
+            const raw = fs.readFileSync(this.filePath, "utf-8");
+            const updated = raw.replace(this.delimiter, `${this.delimiter.slice(0, -4)} attachments="${attachments.join(",")}" -->`);
+            fs.writeFileSync(this.filePath, updated, "utf-8");
+        }
+    }
+}
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

package/dist/transports/http-transport.js

@@ -242,13 +242,14 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                 }
                 const taskDir = getTaskDir(config.projectRoot, taskId);
                 const task = parseTaskFile(taskDir);
+                const pendingPromise = registerPending(taskId, "input", descriptions);
                 await publishEvent(taskId, {
                     event_type: "input-request",
                     host_id: config.hostId,
                     input_descriptions: descriptions,
                     name: task.frontmatter.name,
                 });
-                const response = await registerPending(taskId, "input", descriptions);
+                const response = await pendingPromise;
                 if (response.length === 1 && response[0] === "aborted") {
                     await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "aborted" });
                     if (runId) {
@@ -283,11 +284,12 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                     sendJson(res, 400, { error: "taskId is required" });
                     return;
                 }
+                const pendingPromise = registerPending(taskId, "confirmation");
                 await publishEvent(taskId, {
                     event_type: "confirm-request",
                     host_id: config.hostId,
                 });
-                const response = await registerPending(taskId, "confirmation");
+                const response = await pendingPromise;
                 const confirmed = response[0] === "confirmed";
                 await publishEvent(taskId, {
                     event_type: "confirm-resolved",
@@ -314,13 +316,14 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                     sendJson(res, 400, { error: "taskId and permissions are required" });
                     return;
                 }
+                const pendingPromise = registerPending(taskId, "permission", permissions);
                 await publishEvent(taskId, {
                     event_type: "permission-request",
                     host_id: config.hostId,
                     required_permissions: permissions,
                     name: taskName,
                 });
-                const response = await registerPending(taskId, "permission", permissions);
+                const response = await pendingPromise;
                 const status = response[0];
                 await publishEvent(taskId, {
                     event_type: "permission-resolved",

package/dist/types.d.ts

@@ -60,7 +60,7 @@ export interface ConversationMessage {
     role: "assistant" | "user" | "status";
     time: number;
     content: string;
-    type?: "input" | "permission" | "confirmation" | "started" | "finished" | "failed" | "aborted" | "stopped";
+    type?: "input" | "permission" | "confirmation" | "monitoring" | "started" | "finished" | "failed" | "aborted" | "stopped";
     attachments?: string[];
 }
 export interface RpcMessage {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.4.9",
+  "version": "0.5.1",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",

package/src/commands/run.ts

@@ -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, createRunDir, appendRunMessage, readRunMessages, getRunDir } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir, beginStreamingMessage } 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";
@@ -47,6 +47,21 @@ async function invokeAgentWithRetries(
 ): Promise<InvocationResult> {
   // eslint-disable-next-line no-constant-condition
   while (true) {
+    // Stream agent output to TASKRUN.md in real-time, throttled to 500ms
+    const writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now());
+    let lineBuf = "";
+    let notifyPending = false;
+    let notifyTimer: ReturnType<typeof setTimeout> | undefined;
+
+    function throttledNotify() {
+      if (notifyPending) return;
+      notifyPending = true;
+      notifyTimer = setTimeout(() => {
+        notifyPending = false;
+        publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+      }, 500);
+    }
+
     const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.transientPermissions);
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
@@ -54,19 +69,37 @@ async function invokeAgentWithRetries(
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
+      onData: (chunk) => {
+        lineBuf += chunk;
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? "";
+        const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
+        if (filtered.length > 0) {
+          writer.write(filtered.join("\n") + "\n");
+          throttledNotify();
+        }
+      },
     });
 
+    if (notifyTimer) clearTimeout(notifyTimer);
+
     const outcome: TaskRunningState = 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,
-    });
+    // Flush remaining buffered content
+    if (lineBuf && !lineBuf.startsWith("[PALMIER")) {
+      writer.write(lineBuf);
+    }
+
+    // Include permission requests in the assistant message
+    if (requiredPermissions.length > 0) {
+      const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
+      writer.write(`\n\n**Permissions requested:**\n${permLines}\n`);
+    }
+
+    writer.end(reportFiles.length > 0 ? reportFiles : undefined);
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 
     // Permission handling — agent requested permissions
     if (requiredPermissions.length > 0) {
@@ -76,7 +109,7 @@ async function invokeAgentWithRetries(
         await appendAndNotify(ctx, {
           role: "user",
           time: Date.now(),
-          content: "Permissions denied. Task aborted.",
+          content: "Denied",
           type: "permission",
         });
         return { outcome: "failed" };
@@ -87,11 +120,10 @@ async function invokeAgentWithRetries(
           && !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(", ")}`,
+        content: response === "granted_all" ? "Granted for all" : "Granted",
         type: "permission",
       });
 
@@ -267,6 +299,9 @@ async function runCommandTriggeredMode(
   const commandStr = ctx.task.frontmatter.command!;
   console.log(`[command-triggered] Spawning: ${commandStr}`);
 
+  appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+
   const child = spawnStreamingCommand(commandStr, {
     cwd: getRunDir(ctx.taskDir, ctx.runId),
     env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
@@ -419,7 +454,11 @@ async function requestPermission(
       permissions: requiredPermissions,
     }),
   });
-  const { response } = await res.json() as { response: "granted" | "granted_all" | "aborted" };
+  const body = await res.json() as { response?: string; error?: string };
+  const response = body.response as "granted" | "granted_all" | "aborted" | undefined;
+  if (!response || !["granted", "granted_all", "aborted"].includes(response)) {
+    throw new Error(`Permission request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+  }
   writeTaskStatus(taskDir, {
     running_state: response === "aborted" ? "aborted" : "started",
     time_stamp: Date.now(),
@@ -439,7 +478,11 @@ async function requestConfirmation(
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
   });
-  const { confirmed } = await res.json() as { confirmed: boolean };
+  const body = await res.json() as { confirmed?: boolean; error?: string };
+  if (typeof body.confirmed !== "boolean") {
+    throw new Error(`Confirmation request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+  }
+  const { confirmed } = body;
   writeTaskStatus(taskDir, {
     running_state: confirmed ? "started" : "aborted",
     time_stamp: Date.now(),

package/src/commands/serve.ts

@@ -95,7 +95,13 @@ export async function serveCommand(): Promise<void> {
   saveConfig(config);
   console.log(`Detected agents: ${agents.map((a) => a.key).join(", ") || "none"}`);
 
-  const nc = await connectNats(config);
+  let nc: NatsConnection | undefined;
+  try {
+    nc = await connectNats(config);
+    console.log("[nats] Connected");
+  } catch (err) {
+    console.warn(`[nats] Connection failed (server mode unavailable): ${err}`);
+  }
 
   // Reconcile any tasks stuck from before daemon started
   await checkStaleTasks(config, nc);

package/src/platform/windows.ts

@@ -1,7 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
 import { execFileSync } from "child_process";
-import { spawn as nodeSpawn } from "child_process";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
 import { CONFIG_DIR, loadConfig } from "../config.js";
@@ -94,13 +93,12 @@ export class WindowsPlatform implements PlatformService {
   installDaemon(config: HostConfig): void {
     const script = process.argv[1] || "palmier";
 
-    // Write a VBS launcher that starts the daemon with no visible console window.
-    // VBS doesn't use backslash escaping — only quotes need doubling ("").
-    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
-    fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
-
-    const regValue = `"${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe" "${DAEMON_VBS_FILE}"`;
+    // Create the Task Scheduler entry for the daemon
+    this.ensureDaemonTask(script);
 
+    // Registry Run key triggers the Task Scheduler entry on logon,
+    // so the daemon always runs outside any session's job object.
+    const regValue = `schtasks /run /tn "\\Palmier\\${DAEMON_TASK_NAME}"`;
     try {
       execFileSync("reg", [
         "add", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
@@ -113,24 +111,23 @@ export class WindowsPlatform implements PlatformService {
     }
 
     // Start the daemon now
-    this.spawnDaemon(script);
+    this.startDaemonTask();
 
     console.log("\nHost initialization complete!");
   }
 
   async restartDaemon(): Promise<void> {
-    const script = process.argv[1] || "palmier";
     const oldPid = fs.existsSync(DAEMON_PID_FILE)
       ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
       : null;
 
     if (oldPid && oldPid === String(process.pid)) {
       // We ARE the old daemon (auto-update) — spawn replacement then exit.
-      this.spawnDaemon(script);
+      this.startDaemonTask();
       process.exit(0);
     }
 
-    // Kill old daemon first, then spawn new one.
+    // Kill old daemon by PID
     if (oldPid) {
       try {
         execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
@@ -139,23 +136,53 @@ export class WindowsPlatform implements PlatformService {
       }
     }
 
-    this.spawnDaemon(script);
+    // Also kill any stale palmier serve processes (e.g. leftover from a previous daemon)
+    try {
+      const out = execFileSync("wmic", ["process", "where", `CommandLine like '%palmier%serve%' and ProcessId != '${process.pid}'`, "get", "ProcessId"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
+      for (const line of out.split("\n")) {
+        const pid = line.trim();
+        if (pid && /^\d+$/.test(pid)) {
+          try { execFileSync("taskkill", ["/pid", pid, "/f", "/t"], { windowsHide: true, stdio: "pipe" }); } catch {}
+        }
+      }
+    } catch {
+      // wmic may not be available on all Windows versions
+    }
+
+    this.startDaemonTask();
   }
 
-  private spawnDaemon(script: string): void {
-    // Write a VBS launcher that starts the daemon with no visible console window.
+  /** Create or update the Task Scheduler entry for the daemon. */
+  private ensureDaemonTask(script: string): void {
     const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
     fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
 
-    // Use `cmd /c start` to break out of the SSH session's job object.
-    // Without this, the daemon is killed when the SSH session disconnects.
-    const child = nodeSpawn("cmd", ["/c", "start", "/b", "wscript.exe", DAEMON_VBS_FILE], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-    });
-    child.unref();
-    // PID file will be written by the serve command itself when it starts.
+    const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+    const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
+    const tr = `"${wscript}" "${DAEMON_VBS_FILE}"`;
+    const xml = buildTaskXml(tr, [`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`]);
+    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")]));
+      execFileSync("schtasks", ["/create", "/tn", tn, "/xml", xmlPath, "/f"], { 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 */ }
+    }
+  }
+
+  /** Start the daemon via Task Scheduler (runs 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.");
   }
 

package/src/rpc-handler.ts

@@ -49,8 +49,8 @@ function parseResultFrontmatter(raw: string): Record<string, unknown> {
 
   // If last status is "started", determine if it's a task run or follow-up
   let runningState: string | undefined;
-  if (lastStatus?.type === "started") {
-    runningState = terminalMsg ? "followup" : "started";
+  if (lastStatus?.type === "started" || lastStatus?.type === "monitoring") {
+    runningState = terminalMsg ? "followup" : (lastStatus?.type ?? "started");
   } else {
     runningState = lastStatus?.type;
   }
@@ -151,10 +151,17 @@ const activeFollowups = new Map<string, ChildProcess>();
 export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   function flattenTask(task: ParsedTask) {
     const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
+    const status = readTaskStatus(taskDir);
+    const pending = getPending(task.frontmatter.id);
     return {
       ...task.frontmatter,
       body: task.body,
-      status: readTaskStatus(taskDir),
+      status: status ? {
+        ...status,
+        ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
+        ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
+        ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
+      } : undefined,
     };
   }
 

package/src/spawn-command.ts

@@ -55,6 +55,8 @@ export interface SpawnCommandOptions {
   resolveOnFailure?: boolean;
   /** If provided, write this string to the process's stdin and then close the pipe. */
   stdin?: string;
+  /** Called on each chunk of output (stdout + stderr combined). */
+  onData?: (chunk: string) => void;
 }
 
 /**
@@ -105,10 +107,12 @@ export function spawnCommand(
     child.stdout!.on("data", (d: Buffer) => {
       chunks.push(d);
       if (opts.echoStdout) process.stdout.write(d);
+      if (opts.onData) opts.onData(d.toString("utf-8"));
     });
     child.stderr!.on("data", (d: Buffer) => {
       chunks.push(d);
       process.stderr.write(d);
+      if (opts.onData) opts.onData(d.toString("utf-8"));
     });
 
     let timer: ReturnType<typeof setTimeout> | undefined;

package/src/task.ts

@@ -190,6 +190,43 @@ export function appendRunMessage(
   fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
 }
 
+/**
+ * Begin a streaming assistant message — writes the delimiter only.
+ * Returns a writer that appends content chunks and finalizes the message.
+ */
+export function beginStreamingMessage(
+  taskDir: string,
+  runId: string,
+  time: number,
+): StreamingMessageWriter {
+  const filePath = path.join(taskDir, runId, "TASKRUN.md");
+  const delimiter = `<!-- palmier:message role="assistant" time="${time}" -->`;
+  fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
+  return new StreamingMessageWriter(filePath, delimiter);
+}
+
+export class StreamingMessageWriter {
+  private delimiter: string;
+  constructor(private filePath: string, delimiter: string) {
+    this.delimiter = delimiter;
+  }
+
+  /** Append a chunk of content to the current message. */
+  write(chunk: string): void {
+    fs.appendFileSync(this.filePath, chunk, "utf-8");
+  }
+
+  /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+  end(attachments?: string[]): void {
+    fs.appendFileSync(this.filePath, "\n\n", "utf-8");
+    if (attachments?.length) {
+      const raw = fs.readFileSync(this.filePath, "utf-8");
+      const updated = raw.replace(this.delimiter, `${this.delimiter.slice(0, -4)} attachments="${attachments.join(",")}" -->`);
+      fs.writeFileSync(this.filePath, updated, "utf-8");
+    }
+  }
+}
+
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

package/src/transports/http-transport.ts

@@ -262,6 +262,8 @@ export async function startHttpTransport(
         const taskDir = getTaskDir(config.projectRoot, taskId);
         const task = parseTaskFile(taskDir);
 
+        const pendingPromise = registerPending(taskId, "input", descriptions);
+
         await publishEvent(taskId, {
           event_type: "input-request",
           host_id: config.hostId,
@@ -269,7 +271,7 @@ export async function startHttpTransport(
           name: task.frontmatter.name,
         });
 
-        const response = await registerPending(taskId, "input", descriptions);
+        const response = await pendingPromise;
 
         if (response.length === 1 && response[0] === "aborted") {
           await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "aborted" });
@@ -300,12 +302,14 @@ export async function startHttpTransport(
         const { taskId } = JSON.parse(body) as { taskId: string };
         if (!taskId) { sendJson(res, 400, { error: "taskId is required" }); return; }
 
+        const pendingPromise = registerPending(taskId, "confirmation");
+
         await publishEvent(taskId, {
           event_type: "confirm-request",
           host_id: config.hostId,
         });
 
-        const response = await registerPending(taskId, "confirmation");
+        const response = await pendingPromise;
         const confirmed = response[0] === "confirmed";
 
         await publishEvent(taskId, {
@@ -335,6 +339,8 @@ export async function startHttpTransport(
           return;
         }
 
+        const pendingPromise = registerPending(taskId, "permission", permissions);
+
         await publishEvent(taskId, {
           event_type: "permission-request",
           host_id: config.hostId,
@@ -342,7 +348,7 @@ export async function startHttpTransport(
           name: taskName,
         });
 
-        const response = await registerPending(taskId, "permission", permissions);
+        const response = await pendingPromise;
         const status = response[0] as "granted" | "granted_all" | "aborted";
 
         await publishEvent(taskId, {

package/src/types.ts

@@ -71,7 +71,7 @@ export interface ConversationMessage {
   role: "assistant" | "user" | "status";
   time: number;
   content: string;
-  type?: "input" | "permission" | "confirmation" | "started" | "finished" | "failed" | "aborted" | "stopped";
+  type?: "input" | "permission" | "confirmation" | "monitoring" | "started" | "finished" | "failed" | "aborted" | "stopped";
   attachments?: string[];
 }