palmier 0.4.8 → 0.5.0

package/README.md

@@ -85,7 +85,9 @@ palmier sessions revoke-all
 
 The `init` command:
 - Detects installed agent CLIs (Claude Code, Gemini CLI, Codex CLI, GitHub Copilot) and caches the result
-- Saves host configuration to `~/.config/palmier/host.json`
+- Configures access modes (HTTP port, LAN access)
+- Shows a summary and asks for confirmation before making changes
+- Registers with the Palmier server, saves configuration to `~/.config/palmier/host.json`
 - Installs a background daemon (systemd user service on Linux, Registry Run key on Windows)
 - Auto-enters pair mode to connect your first device
 
@@ -128,76 +130,9 @@ 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. 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.
-- **Conversational run history** — each run gets its own directory (`tasks/<id>/<timestamp>/`) with a `TASKRUN.md` file containing a conversational thread: assistant messages (agent output), user messages (input responses, permission grants, confirmations), and status entries (started, finished, failed, aborted, stopped). The agent runs inside the run directory, so each run's session files and artifacts are isolated. The PWA displays runs as a chat-like thread with follow-up support.
-- **Follow-up messages** — after a task run completes, users can send follow-up messages from the run detail view. The agent is invoked inline by the serve daemon (no new process spawning), and the response is appended to the same conversation thread.
-- **Real-time updates** — task status changes and result updates are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (local/LAN mode). The run detail view live-updates as the agent produces output. Events are scoped to specific runs.
 - **Agent HTTP endpoints** — the serve daemon exposes localhost-only endpoints (`/notify`, `/request-input`) that agents call to send push notifications and request user input during task execution.
 
-## NATS Subjects
-
-| Subject | Direction | Description |
-|---|---|---|
-| `host.<hostId>.rpc.<method>` | Client → Host | RPC request/reply (e.g., `task.list`, `task.create`) |
-| `host-event.<hostId>.<taskId>` | Host → Client | Real-time task events (`running-state`, `result-updated`, `confirm-request`, `permission-request`, `input-request`) |
-| `host.<hostId>.push.send` | Host → Server | Request server to deliver a push notification |
-| `pair.<code>` | Client → Host | OTP pairing request/reply |
-
-## Project Structure
-
-```
-src/
-  index.ts            # CLI entrypoint (commander setup)
-  config.ts           # Host configuration (read/write ~/.config/palmier)
-  rpc-handler.ts      # Transport-agnostic RPC handler (with session validation)
-  session-store.ts    # Session token management (~/.config/palmier/sessions.json)
-  nats-client.ts      # NATS connection helper
-  spawn-command.ts    # Shared helper for spawning CLI tools
-  task.ts             # Task file management
-  types.ts            # Shared type definitions
-  pending-requests.ts # In-memory registry for held HTTP connections (confirmation, permission, input)
-  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
-    copilot.ts        # GitHub Copilot agent implementation
-    openclaw.ts       # OpenClaw agent implementation
-  commands/
-    init.ts           # Interactive setup wizard (auto-pair)
-    pair.ts           # OTP code generation and pairing handler
-    sessions.ts       # Session token management CLI (list, revoke, revoke-all)
-    info.ts           # Print host connection info
-
-    serve.ts          # NATS + HTTP transport startup, crash detection polling
-    restart.ts        # Daemon restart (cross-platform)
-    run.ts            # Single task execution
-  platform/
-    platform.ts       # PlatformService interface
-    index.ts          # Platform factory (Linux vs Windows)
-    linux.ts          # Linux: systemd daemon, timers, systemctl task control
-    windows.ts        # Windows: Registry Run key, Task Scheduler, schtasks-based task control
-  transports/
-    nats-transport.ts # NATS subscription loop (host.<hostId>.rpc.>)
-    http-transport.ts # HTTP server with RPC, SSE, PWA reverse proxy, and internal event endpoints
-```
-
-## Agent HTTP Endpoints
-
-The serve daemon exposes localhost-only HTTP endpoints for agents during task execution. The port is baked into the agent's system prompt automatically.
-
-| Endpoint | Method | Description |
-|---|---|---|
-| `/notify` | POST | Send a push notification (requires server mode) |
-| `/request-input` | POST | Request user input; blocks until a response is provided |
-
-See [agent-instructions.md](src/agents/agent-instructions.md) for usage examples.
-
 ## Uninstalling
 
 To fully remove Palmier from a machine:

package/dist/agents/agent-instructions.md

@@ -24,7 +24,7 @@ If the task fails because a tool was denied or you lack the required permissions
 
 The following HTTP endpoints are available at http://localhost:{{PORT}} during task execution. Use curl to call them.
 
-**Requesting user input** — When you need information from the user (credentials, questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout. Instead, POST to `/request-input` with:
+**Requesting user input** — When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment. Instead, POST to `/request-input` with:
 ```json
 {"taskId":"{{TASK_ID}}","descriptions":["question 1","question 2"]}
 ```

package/dist/agents/gemini.js

@@ -5,12 +5,12 @@ export class GeminiAgent {
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "gemini",
-            args: ["--approval-mode", "auto_edit", "--prompt", prompt],
+            args: ["--prompt", prompt],
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const fullPrompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-        const args = ["--allowed-tools", "web_fetch"];
+        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+        const args = ["--approval-mode", "auto_edit", "--allowed-tools", "web_fetch"];
         const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
         if (allPerms.length > 0) {
             for (const p of allPerms) {
@@ -20,8 +20,8 @@ export class GeminiAgent {
         if (followupPrompt) {
             args.push("--resume");
         } // continue mode for followups
-        args.push("--prompt", "-"); // read prompt from stdin
-        return { command: "gemini", args, stdin: fullPrompt };
+        args.push("--prompt", prompt);
+        return { command: "gemini", args };
     }
     async init() {
         try {

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";
@@ -16,9 +16,23 @@ import { publishHostEvent } from "../events.js";
  * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
  * (for command-triggered mode this is the per-line augmented task).
  */
-async function invokeAgentWithContinuation(ctx, invokeTask) {
+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 invokeAgentWithContinuation(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 invokeAgentWithContinuation(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") {
@@ -174,7 +203,7 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.body || task.frontmatter.user_prompt,
             });
-            const result = await invokeAgentWithContinuation(ctx, task);
+            const result = await invokeAgentWithRetries(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
@@ -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) },
@@ -252,7 +283,7 @@ async function runCommandTriggeredMode(ctx) {
             frontmatter: { ...ctx.task.frontmatter, user_prompt: perLinePrompt },
             body: "",
         };
-        const result = await invokeAgentWithContinuation(ctx, perLineTask);
+        const result = await invokeAgentWithRetries(ctx, perLineTask);
         if (result.outcome === "finished") {
             invocationsSucceeded++;
         }

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,17 +94,16 @@ 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.
@@ -117,20 +115,43 @@ export class WindowsPlatform {
                 // Process may have already exited
             }
         }
-        this.spawnDaemon(script);
+        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");
         const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
-        const child = nodeSpawn(wscript, [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 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;

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,8 +57,15 @@ 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"));
         });
-        child.stderr.on("data", (d) => process.stderr.write(d));
         let timer;
         if (opts.timeout) {
             timer = setTimeout(() => {

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/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.8",
+  "version": "0.5.0",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",

package/src/agents/agent-instructions.md

@@ -24,7 +24,7 @@ If the task fails because a tool was denied or you lack the required permissions
 
 The following HTTP endpoints are available at http://localhost:{{PORT}} during task execution. Use curl to call them.
 
-**Requesting user input** — When you need information from the user (credentials, questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout. Instead, POST to `/request-input` with:
+**Requesting user input** — When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment. Instead, POST to `/request-input` with:
 ```json
 {"taskId":"{{TASK_ID}}","descriptions":["question 1","question 2"]}
 ```

package/src/agents/gemini.ts

@@ -8,13 +8,13 @@ export class GeminiAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "gemini",
-      args: ["--approval-mode", "auto_edit", "--prompt", prompt],
+      args: ["--prompt", prompt],
     };
   }
 
   getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const fullPrompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-    const args = ["--allowed-tools", "web_fetch"];
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["--approval-mode", "auto_edit", "--allowed-tools", "web_fetch"];
 
     const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
     if (allPerms.length > 0) {
@@ -24,9 +24,9 @@ export class GeminiAgent implements AgentTool {
     }
 
     if (followupPrompt) {args.push("--resume");} // continue mode for followups
-    args.push("--prompt", "-"); // read prompt from stdin
+    args.push("--prompt", prompt);
     
-    return { command: "gemini", args, stdin: fullPrompt };
+    return { command: "gemini", args };
   }
 
   async init(): Promise<boolean> {

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";
@@ -41,12 +41,27 @@ interface InvocationResult {
  * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
  * (for command-triggered mode this is the per-line augmented task).
  */
-async function invokeAgentWithContinuation(
+async function invokeAgentWithRetries(
   ctx: InvocationContext,
   invokeTask: ParsedTask,
 ): 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 invokeAgentWithContinuation(
       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 invokeAgentWithContinuation(
         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 invokeAgentWithContinuation(
           && !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",
       });
 
@@ -226,7 +258,7 @@ export async function runCommand(taskId: string): Promise<void> {
         content: task.body || task.frontmatter.user_prompt,
       });
 
-      const result = await invokeAgentWithContinuation(ctx, task);
+      const result = await invokeAgentWithRetries(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
       appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
       await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
@@ -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) },
@@ -313,7 +348,7 @@ async function runCommandTriggeredMode(
       body: "",
     };
 
-    const result = await invokeAgentWithContinuation(ctx, perLineTask);
+    const result = await invokeAgentWithRetries(ctx, perLineTask);
     if (result.outcome === "finished") {
       invocationsSucceeded++;
     } else {

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,20 +111,19 @@ 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);
     }
 
@@ -139,22 +136,40 @@ export class WindowsPlatform implements PlatformService {
       }
     }
 
-    this.spawnDaemon(script);
+    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");
 
     const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
-    const child = nodeSpawn(wscript, [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 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;
   }

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,8 +107,13 @@ 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"));
     });
-    child.stderr!.on("data", (d: Buffer) => process.stderr.write(d));
 
     let timer: ReturnType<typeof setTimeout> | undefined;
     if (opts.timeout) {

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/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[];
 }