palmier 0.4.0 → 0.4.2

package/dist/commands/mcpserver.js

@@ -4,6 +4,8 @@ import { z } from "zod";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile } from "../task.js";
+import { requestUserInput, publishInputResolved } from "../user-input.js";
 export async function mcpserverCommand() {
     const config = loadConfig();
     const nc = await connectNats(config);
@@ -12,7 +14,7 @@ export async function mcpserverCommand() {
     // send-push-notification requires NATS — only register when server mode is enabled
     if (nc) {
         server.registerTool("send-push-notification", {
-            description: "Send a push notification to all paired devices via the Palmier platform",
+            description: "Send a push notification to the user",
             inputSchema: {
                 title: z.string().describe("Notification title"),
                 body: z.string().describe("Notification body text"),
@@ -49,6 +51,37 @@ export async function mcpserverCommand() {
             }
         });
     }
+    const taskId = process.env.PALMIER_TASK_ID;
+    if (taskId) {
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        const task = parseTaskFile(taskDir);
+        server.registerTool("request-user-input", {
+            description: "Request input from the user. The user will see the descriptions and can provide values or abort.",
+            inputSchema: {
+                descriptions: z.array(z.string()).describe("List of input descriptions to show the user"),
+            },
+        }, async (args) => {
+            try {
+                const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, args.descriptions);
+                await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
+                if (response === "aborted") {
+                    return {
+                        content: [{ type: "text", text: "User aborted the input request." }],
+                    };
+                }
+                const lines = args.descriptions.map((desc, i) => `${desc}: ${response[i]}`).join("\n");
+                return {
+                    content: [{ type: "text", text: lines }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: "text", text: `Error requesting user input: ${err}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Graceful shutdown

package/dist/commands/run.js

@@ -4,22 +4,24 @@ 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 } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile } 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 { 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.
  */
-function writeResult(taskDir, taskName, taskSnapshotName, runningState, startTime, endTime, output, reportFiles, requiredPermissions) {
-    const resultFileName = `RESULT-${endTime}.md`;
+/**
+ * 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");
-    return resultFileName;
 }
 /**
  * Invoke the agent CLI with a retry loop for permissions and user input.
@@ -66,7 +68,7 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
         // Input retry
         const inputRequests = parseInputRequests(result.output);
         if (outcome === "failed" && inputRequests.length > 0) {
-            const response = await requestUserInput(ctx.nc, ctx.config, ctx.task, ctx.taskDir, inputRequests);
+            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 };
@@ -79,6 +81,18 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
         return { output: result.output, outcome, reportFiles, requiredPermissions };
     }
 }
+/**
+ * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ */
+function findStartedResultFile(taskDir) {
+    const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
+        if (content.includes("running_state: started"))
+            return file;
+    }
+    return null;
+}
 /**
  * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
  * respect that instead of overwriting with the process's own outcome.
@@ -98,20 +112,28 @@ export async function runCommand(taskId) {
     const task = parseTaskFile(taskDir);
     console.log(`Running task: ${taskId}`);
     let nc;
-    const startTime = Date.now();
     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`;
-    fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
+        fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    }
     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);
+        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(nc, config, task, taskDir);
@@ -120,9 +142,8 @@ export async function runCommand(taskId) {
             if (!confirmed) {
                 console.log("Task aborted by user.");
                 const endTime = Date.now();
-                const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-                appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName);
+                finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
+                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
                 await cleanup();
                 return;
             }
@@ -139,24 +160,23 @@ export async function runCommand(taskId) {
             // Command-triggered mode
             const result = await runCommandTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
-            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+            finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
             console.log(`Task ${taskId} completed (command-triggered).`);
         }
         else {
             // Standard execution
             const result = await invokeAgentWithRetry(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+            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,
                 });
             }
             console.log(`Task ${taskId} completed.`);
@@ -167,9 +187,8 @@ export async function runCommand(taskId) {
         const endTime = Date.now();
         const outcome = resolveOutcome(taskDir, "failed");
         const errorMsg = err instanceof Error ? err.message : String(err);
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
         process.exitCode = 1;
     }
     finally {
@@ -302,7 +321,7 @@ async function runCommandTriggeredMode(ctx) {
     ].join("\n");
     return { outcome: "finished", endTime, output: summary };
 }
-async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName) {
+async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, resultFile) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
@@ -310,6 +329,8 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
         payload.name = taskName;
+    if (resultFile)
+        payload.result_file = resultFile;
     await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 /**
@@ -322,22 +343,6 @@ async function publishConfirmResolved(nc, config, taskId, status) {
         status,
     });
 }
-/**
- * Watch status.json until user_input is populated by an RPC call, then resolve.
- * All interactive request flows (confirmation, permission, user input) share this.
- */
-function waitForUserInput(taskDir) {
-    const statusPath = path.join(taskDir, "status.json");
-    return new Promise((resolve) => {
-        const watcher = fs.watch(statusPath, () => {
-            const status = readTaskStatus(taskDir);
-            if (!status || !status.user_input?.length)
-                return;
-            watcher.close();
-            resolve(status.user_input);
-        });
-    });
-}
 async function requestPermission(nc, config, task, taskDir, requiredPermissions) {
     const currentStatus = readTaskStatus(taskDir);
     writeTaskStatus(taskDir, { ...currentStatus, pending_permission: requiredPermissions });
@@ -362,30 +367,6 @@ async function publishPermissionResolved(nc, config, taskId, status) {
         status,
     });
 }
-async function requestUserInput(nc, config, task, taskDir, inputDescriptions) {
-    const currentStatus = readTaskStatus(taskDir);
-    writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
-    await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-        event_type: "input-request",
-        host_id: config.hostId,
-        input_descriptions: inputDescriptions,
-        name: task.frontmatter.name,
-    });
-    const userInput = await waitForUserInput(taskDir);
-    if (userInput.length === 1 && userInput[0] === "aborted") {
-        writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
-        return "aborted";
-    }
-    writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
-    return userInput;
-}
-async function publishInputResolved(nc, config, taskId, status) {
-    await publishHostEvent(nc, config.hostId, taskId, {
-        event_type: "input-resolved",
-        host_id: config.hostId,
-        status,
-    });
-}
 async function requestConfirmation(nc, config, task, taskDir) {
     const currentStatus = readTaskStatus(taskDir);
     writeTaskStatus(taskDir, { ...currentStatus, pending_confirmation: true });

package/dist/commands/serve.js

@@ -7,7 +7,6 @@ import { startNatsTransport } from "../transports/nats-transport.js";
 import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
-import { checkForUpdate } from "../update-checker.js";
 import { detectAgents } from "../agents/agent.js";
 import { saveConfig } from "../config.js";
 import { CONFIG_DIR } from "../config.js";
@@ -88,9 +87,6 @@ export async function serveCommand() {
             console.error("[monitor] Error checking stale tasks:", err);
         });
     }, POLL_INTERVAL_MS);
-    // Check for updates on startup and every 24 hours
-    checkForUpdate().catch(() => { });
-    setInterval(() => { checkForUpdate().catch(() => { }); }, 24 * 60 * 60 * 1000);
     const handleRpc = createRpcHandler(config, nc);
     await startNatsTransport(config, handleRpc, nc);
 }

package/dist/platform/windows.js

@@ -110,31 +110,34 @@ export class WindowsPlatform {
         const oldPid = fs.existsSync(DAEMON_PID_FILE)
             ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
             : null;
-        // Spawn the new daemon before killing the old one.
-        this.spawnDaemon(script);
         if (oldPid && oldPid === String(process.pid)) {
-            // We ARE the old daemon (auto-update) — exit so only the new one runs.
+            // We ARE the old daemon (auto-update) — spawn replacement then exit.
+            this.spawnDaemon(script);
             process.exit(0);
         }
-        else if (oldPid) {
+        // Kill old daemon first, then spawn new one.
+        if (oldPid) {
             try {
-                execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
+                execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
             }
             catch {
                 // Process may have already exited
             }
         }
+        this.spawnDaemon(script);
     }
     spawnDaemon(script) {
-        const child = nodeSpawn(process.execPath, [script, "serve"], {
+        // Write a VBS launcher that starts the daemon with no visible console window.
+        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,
         });
-        if (child.pid) {
-            fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
-        }
         child.unref();
+        // PID file will be written by the serve command itself when it starts.
         console.log("Palmier daemon started.");
     }
     installTaskTimer(config, task) {

package/dist/rpc-handler.js

@@ -2,14 +2,15 @@ import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createResultFile } from "./task.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
 import { validateSession } from "./session-store.js";
 import { publishHostEvent } from "./events.js";
-import { currentVersion, getLatestVersion, performUpdate } from "./update-checker.js";
+import { currentVersion, performUpdate } from "./update-checker.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PLAN_GENERATION_PROMPT = fs.readFileSync(path.join(__dirname, "commands", "plan-generation.md"), "utf-8");
 /**
@@ -108,7 +109,6 @@ export function createRpcHandler(config, nc) {
                     tasks: tasks.map((task) => flattenTask(task)),
                     agents: config.agents ?? [],
                     version: currentVersion,
-                    latest_version: getLatestVersion(),
                 };
             }
             case "task.create": {
@@ -205,11 +205,49 @@ export function createRpcHandler(config, nc) {
                 removeFromTaskList(config.projectRoot, params.id);
                 return { ok: true, task_id: params.id };
             }
+            case "task.run_oneoff": {
+                const params = request.params;
+                const id = randomUUID();
+                const taskDir = getTaskDir(config.projectRoot, id);
+                const name = params.user_prompt.slice(0, 60);
+                const task = {
+                    frontmatter: {
+                        id,
+                        name,
+                        user_prompt: params.user_prompt,
+                        agent: params.agent,
+                        triggers: [],
+                        triggers_enabled: false,
+                        requires_confirmation: params.requires_confirmation ?? false,
+                        ...(params.command ? { command: params.command } : {}),
+                    },
+                    body: "",
+                };
+                writeTaskFile(taskDir, task);
+                // Do NOT append to tasks.jsonl — this is a one-off run
+                // Create initial result file so it appears in runs list immediately
+                const resultFileName = createResultFile(taskDir, name, Date.now());
+                appendHistory(config.projectRoot, { task_id: id, result_file: resultFileName });
+                // Spawn `palmier run <id>` directly as a detached process
+                const script = process.argv[1] || "palmier";
+                const child = spawn(process.execPath, [script, "run", id], {
+                    detached: true,
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                child.unref();
+                return { ok: true, task_id: id, result_file: resultFileName };
+            }
             case "task.run": {
                 const params = request.params;
                 try {
+                    // Create initial result file so it appears in runs list immediately
+                    const runTaskDir = getTaskDir(config.projectRoot, params.id);
+                    const runTask = parseTaskFile(runTaskDir);
+                    const runResultFileName = createResultFile(runTaskDir, runTask.frontmatter.name, Date.now());
+                    appendHistory(config.projectRoot, { task_id: params.id, result_file: runResultFileName });
                     await getPlatform().startTask(params.id);
-                    return { ok: true, task_id: params.id };
+                    return { ok: true, task_id: params.id, result_file: runResultFileName };
                 }
                 catch (err) {
                     const e = err;

package/dist/task.d.ts

@@ -38,6 +38,12 @@ export declare function writeTaskStatus(taskDir: string, status: TaskStatus): vo
  * Returns undefined if the file doesn't exist.
  */
 export declare function readTaskStatus(taskDir: string): TaskStatus | undefined;
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export declare function createResultFile(taskDir: string, taskName: string, startTime: number): string;
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/dist/task.js

@@ -129,6 +129,18 @@ export function readTaskStatus(taskDir) {
         return undefined;
     }
 }
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export function createResultFile(taskDir, taskName, startTime) {
+    const resultFileName = `RESULT-${startTime}.md`;
+    const taskSnapshotName = `TASK-${startTime}.md`;
+    const content = `---\ntask_name: ${taskName}\nrunning_state: started\nstart_time: ${startTime}\ntask_file: ${taskSnapshotName}\n---\n`;
+    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+    return resultFileName;
+}
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/dist/update-checker.d.ts

@@ -1,14 +1,6 @@
 /** True when running from a source checkout (has .git) rather than a global npm install. */
 export declare const isDevBuild: boolean;
 export declare const currentVersion: string;
-/**
- * Check the npm registry for the latest version of palmier.
- */
-export declare function checkForUpdate(): Promise<void>;
-/**
- * Get the latest version from npm, or null if not yet checked.
- */
-export declare function getLatestVersion(): string | null;
 /**
  * Run the update and restart the daemon.
  * Returns an error message if the update fails.

package/dist/update-checker.js

@@ -9,41 +9,6 @@ const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "
 /** True when running from a source checkout (has .git) rather than a global npm install. */
 export const isDevBuild = fs.existsSync(path.join(packageRoot, ".git"));
 export const currentVersion = isDevBuild ? `${pkg.version}-dev` : pkg.version;
-let latestVersion = null;
-let lastCheckTime = 0;
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-/**
- * Check the npm registry for the latest version of palmier.
- */
-export async function checkForUpdate() {
-    if (isDevBuild)
-        return;
-    const now = Date.now();
-    if (now - lastCheckTime < CHECK_INTERVAL_MS)
-        return;
-    lastCheckTime = now;
-    try {
-        const res = await fetch("https://registry.npmjs.org/palmier/latest", {
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (!res.ok)
-            return;
-        const data = (await res.json());
-        if (data.version) {
-            latestVersion = data.version;
-            console.log(`[update] Latest version: ${data.version} (current: ${currentVersion})`);
-        }
-    }
-    catch {
-        // Network errors are expected (offline, etc.)
-    }
-}
-/**
- * Get the latest version from npm, or null if not yet checked.
- */
-export function getLatestVersion() {
-    return latestVersion;
-}
 /**
  * Run the update and restart the daemon.
  * Returns an error message if the update fails.
@@ -60,7 +25,6 @@ export async function performUpdate() {
             return `Update failed. Please run manually:\nnpm update -g palmier`;
         }
         console.log("[update] Update installed, restarting daemon...");
-        latestVersion = null;
         // Small delay to allow the RPC response to be sent
         setTimeout(() => {
             getPlatform().restartDaemon().catch((err) => {

package/dist/user-input.d.ts

@@ -0,0 +1,15 @@
+import type { HostConfig } from "./types.js";
+import type { NatsConnection } from "nats";
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export declare function waitForUserInput(taskDir: string): Promise<string[]>;
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export declare function requestUserInput(nc: NatsConnection | undefined, config: HostConfig, taskId: string, taskName: string, taskDir: string, inputDescriptions: string[]): Promise<string[] | "aborted">;
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export declare function publishInputResolved(nc: NatsConnection | undefined, config: HostConfig, taskId: string, status: "provided" | "aborted"): Promise<void>;
+//# sourceMappingURL=user-input.d.ts.map

package/dist/user-input.js

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as path from "path";
+import { readTaskStatus, writeTaskStatus } from "./task.js";
+import { publishHostEvent } from "./events.js";
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export function waitForUserInput(taskDir) {
+    const statusPath = path.join(taskDir, "status.json");
+    return new Promise((resolve) => {
+        const watcher = fs.watch(statusPath, () => {
+            const status = readTaskStatus(taskDir);
+            if (!status || !status.user_input?.length)
+                return;
+            watcher.close();
+            resolve(status.user_input);
+        });
+    });
+}
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export async function requestUserInput(nc, config, taskId, taskName, taskDir, inputDescriptions) {
+    const currentStatus = readTaskStatus(taskDir);
+    writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
+    await publishHostEvent(nc, config.hostId, taskId, {
+        event_type: "input-request",
+        host_id: config.hostId,
+        input_descriptions: inputDescriptions,
+        name: taskName,
+    });
+    const userInput = await waitForUserInput(taskDir);
+    if (userInput.length === 1 && userInput[0] === "aborted") {
+        writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
+        return "aborted";
+    }
+    writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
+    return userInput;
+}
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export async function publishInputResolved(nc, config, taskId, status) {
+    await publishHostEvent(nc, config.hostId, taskId, {
+        event_type: "input-resolved",
+        host_id: config.hostId,
+        status,
+    });
+}
+//# sourceMappingURL=user-input.js.map

package/package.json

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

package/src/commands/mcpserver.ts

@@ -4,6 +4,8 @@ import { z } from "zod";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile } from "../task.js";
+import { requestUserInput, publishInputResolved } from "../user-input.js";
 export async function mcpserverCommand(): Promise<void> {
   const config = loadConfig();
   const nc = await connectNats(config);
@@ -20,7 +22,7 @@ export async function mcpserverCommand(): Promise<void> {
     server.registerTool(
       "send-push-notification",
       {
-        description: "Send a push notification to all paired devices via the Palmier platform",
+        description: "Send a push notification to the user",
         inputSchema: {
           title: z.string().describe("Notification title"),
           body: z.string().describe("Notification body text"),
@@ -63,6 +65,44 @@ export async function mcpserverCommand(): Promise<void> {
     );
   }
 
+  const taskId = process.env.PALMIER_TASK_ID;
+  if (taskId) {
+    const taskDir = getTaskDir(config.projectRoot, taskId);
+    const task = parseTaskFile(taskDir);
+
+    server.registerTool(
+      "request-user-input",
+      {
+        description: "Request input from the user. The user will see the descriptions and can provide values or abort.",
+        inputSchema: {
+          descriptions: z.array(z.string()).describe("List of input descriptions to show the user"),
+        },
+      },
+      async (args) => {
+        try {
+          const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, args.descriptions);
+          await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
+
+          if (response === "aborted") {
+            return {
+              content: [{ type: "text" as const, text: "User aborted the input request." }],
+            };
+          }
+
+          const lines = args.descriptions.map((desc: string, i: number) => `${desc}: ${response[i]}`).join("\n");
+          return {
+            content: [{ type: "text" as const, text: lines }],
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text" as const, text: `Error requesting user input: ${err}` }],
+            isError: true,
+          };
+        }
+      }
+    );
+  }
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
 

package/src/commands/run.ts

@@ -4,12 +4,13 @@ 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 } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile } 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 type { AgentTool } from "../agents/agent.js";
 import { publishHostEvent } from "../events.js";
+import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
 import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
 import type { NatsConnection } from "nats";
 
@@ -17,8 +18,13 @@ import type { NatsConnection } from "nats";
  * Write a time-stamped RESULT file with frontmatter.
  * Always generated, even for abort/fail.
  */
-function writeResult(
+
+/**
+ * Update an existing result file with the final outcome.
+ */
+function finalizeResultFile(
   taskDir: string,
+  resultFileName: string,
   taskName: string,
   taskSnapshotName: string,
   runningState: string,
@@ -27,13 +33,11 @@ function writeResult(
   output: string,
   reportFiles: string[],
   requiredPermissions: RequiredPermission[],
-): string {
-  const resultFileName = `RESULT-${endTime}.md`;
+): void {
   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");
-  return resultFileName;
 }
 
 /**
@@ -115,7 +119,7 @@ async function invokeAgentWithRetry(
     // Input retry
     const inputRequests = parseInputRequests(result.output);
     if (outcome === "failed" && inputRequests.length > 0) {
-      const response = await requestUserInput(ctx.nc, ctx.config, ctx.task, ctx.taskDir, inputRequests);
+      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") {
@@ -132,6 +136,18 @@ async function invokeAgentWithRetry(
   }
 }
 
+/**
+ * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ */
+function findStartedResultFile(taskDir: string): string | null {
+  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;
+}
+
 /**
  * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
  * respect that instead of overwriting with the process's own outcome.
@@ -152,12 +168,18 @@ export async function runCommand(taskId: string): Promise<void> {
   console.log(`Running task: ${taskId}`);
 
   let nc: NatsConnection | undefined;
-  const startTime = Date.now();
   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`;
-  fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+  if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
+    fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+  }
 
   const cleanup = async () => {
     if (nc && !nc.isClosed()) {
@@ -165,11 +187,15 @@ export async function runCommand(taskId: string): Promise<void> {
     }
   };
 
+  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);
+    await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
 
     // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
@@ -179,9 +205,8 @@ export async function runCommand(taskId: string): Promise<void> {
       if (!confirmed) {
         console.log("Task aborted by user.");
         const endTime = Date.now();
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName);
+        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
+        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
         await cleanup();
         return;
       }
@@ -200,21 +225,16 @@ export async function runCommand(taskId: string): Promise<void> {
       // Command-triggered mode
       const result = await runCommandTriggeredMode(ctx);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      const resultFileName = writeResult(
-        taskDir, taskName, taskSnapshotName, outcome,
-        startTime, result.endTime, result.output, [], [],
-      );
-      appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
       console.log(`Task ${taskId} completed (command-triggered).`);
     } else {
       // Standard execution
       const result = await invokeAgentWithRetry(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
 
-      const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-      appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+      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, {
@@ -222,6 +242,7 @@ export async function runCommand(taskId: string): Promise<void> {
           name: taskName,
           report_files: result.reportFiles,
           running_state: outcome,
+          result_file: resultFileName,
         });
       }
 
@@ -232,9 +253,8 @@ export async function runCommand(taskId: string): Promise<void> {
     const endTime = Date.now();
     const outcome = resolveOutcome(taskDir, "failed");
     const errorMsg = err instanceof Error ? err.message : String(err);
-    const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+    finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
+    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
     process.exitCode = 1;
   } finally {
     await cleanup();
@@ -388,6 +408,7 @@ async function publishTaskEvent(
   taskId: string,
   eventType: TaskRunningState,
   taskName?: string,
+  resultFile?: string,
 ): Promise<void> {
   writeTaskStatus(taskDir, {
     running_state: eventType,
@@ -396,6 +417,7 @@ async function publishTaskEvent(
 
   const payload: Record<string, unknown> = { event_type: "running-state", running_state: eventType };
   if (taskName) payload.name = taskName;
+  if (resultFile) payload.result_file = resultFile;
   await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 
@@ -415,22 +437,6 @@ async function publishConfirmResolved(
   });
 }
 
-/**
- * Watch status.json until user_input is populated by an RPC call, then resolve.
- * All interactive request flows (confirmation, permission, user input) share this.
- */
-function waitForUserInput(taskDir: string): Promise<string[]> {
-  const statusPath = path.join(taskDir, "status.json");
-  return new Promise<string[]>((resolve) => {
-    const watcher = fs.watch(statusPath, () => {
-      const status = readTaskStatus(taskDir);
-      if (!status || !status.user_input?.length) return;
-      watcher.close();
-      resolve(status.user_input);
-    });
-  });
-}
-
 async function requestPermission(
   nc: NatsConnection | undefined,
   config: HostConfig,
@@ -470,45 +476,6 @@ async function publishPermissionResolved(
   });
 }
 
-async function requestUserInput(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  task: ParsedTask,
-  taskDir: string,
-  inputDescriptions: string[],
-): Promise<string[] | "aborted"> {
-  const currentStatus = readTaskStatus(taskDir)!;
-  writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
-
-  await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-    event_type: "input-request",
-    host_id: config.hostId,
-    input_descriptions: inputDescriptions,
-    name: task.frontmatter.name,
-  });
-
-  const userInput = await waitForUserInput(taskDir);
-  if (userInput.length === 1 && userInput[0] === "aborted") {
-    writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
-    return "aborted";
-  }
-  writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
-  return userInput;
-}
-
-async function publishInputResolved(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  taskId: string,
-  status: "provided" | "aborted",
-): Promise<void> {
-  await publishHostEvent(nc, config.hostId, taskId, {
-    event_type: "input-resolved",
-    host_id: config.hostId,
-    status,
-  });
-}
-
 async function requestConfirmation(
   nc: NatsConnection | undefined,
   config: HostConfig,

package/src/commands/serve.ts

@@ -7,7 +7,6 @@ import { startNatsTransport } from "../transports/nats-transport.js";
 import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
-import { checkForUpdate } from "../update-checker.js";
 import { detectAgents } from "../agents/agent.js";
 import { saveConfig } from "../config.js";
 import type { HostConfig } from "../types.js";
@@ -109,10 +108,6 @@ export async function serveCommand(): Promise<void> {
     });
   }, POLL_INTERVAL_MS);
 
-  // Check for updates on startup and every 24 hours
-  checkForUpdate().catch(() => {});
-  setInterval(() => { checkForUpdate().catch(() => {}); }, 24 * 60 * 60 * 1000);
-
   const handleRpc = createRpcHandler(config, nc);
   await startNatsTransport(config, handleRpc, nc);
 }

package/src/platform/windows.ts

@@ -131,31 +131,37 @@ export class WindowsPlatform implements PlatformService {
       ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
       : null;
 
-    // Spawn the new daemon before killing the old one.
-    this.spawnDaemon(script);
-
     if (oldPid && oldPid === String(process.pid)) {
-      // We ARE the old daemon (auto-update) — exit so only the new one runs.
+      // We ARE the old daemon (auto-update) — spawn replacement then exit.
+      this.spawnDaemon(script);
       process.exit(0);
-    } else if (oldPid) {
+    }
+
+    // Kill old daemon first, then spawn new one.
+    if (oldPid) {
       try {
-        execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
+        execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
       } catch {
         // Process may have already exited
       }
     }
+
+    this.spawnDaemon(script);
   }
 
   private spawnDaemon(script: string): void {
-    const child = nodeSpawn(process.execPath, [script, "serve"], {
+    // Write a VBS launcher that starts the daemon with no visible console window.
+    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,
     });
-    if (child.pid) {
-      fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
-    }
     child.unref();
+    // PID file will be written by the serve command itself when it starts.
     console.log("Palmier daemon started.");
   }
 

package/src/rpc-handler.ts

@@ -2,15 +2,16 @@ import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
 import { type NatsConnection } from "nats";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createResultFile } from "./task.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
 import { validateSession } from "./session-store.js";
 import { publishHostEvent } from "./events.js";
-import { currentVersion, getLatestVersion, performUpdate } from "./update-checker.js";
+import { currentVersion, performUpdate } from "./update-checker.js";
 import type { HostConfig, ParsedTask, RpcMessage } from "./types.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -123,7 +124,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
           version: currentVersion,
-          latest_version: getLatestVersion(),
         };
       }
 
@@ -243,11 +243,61 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true, task_id: params.id };
       }
 
+      case "task.run_oneoff": {
+        const params = request.params as {
+          user_prompt: string;
+          agent: string;
+          requires_confirmation?: boolean;
+          command?: string;
+        };
+
+        const id = randomUUID();
+        const taskDir = getTaskDir(config.projectRoot, id);
+        const name = params.user_prompt.slice(0, 60);
+        const task: ParsedTask = {
+          frontmatter: {
+            id,
+            name,
+            user_prompt: params.user_prompt,
+            agent: params.agent,
+            triggers: [],
+            triggers_enabled: false,
+            requires_confirmation: params.requires_confirmation ?? false,
+            ...(params.command ? { command: params.command } : {}),
+          },
+          body: "",
+        };
+
+        writeTaskFile(taskDir, task);
+        // Do NOT append to tasks.jsonl — this is a one-off run
+
+        // Create initial result file so it appears in runs list immediately
+        const resultFileName = createResultFile(taskDir, name, Date.now());
+        appendHistory(config.projectRoot, { task_id: id, result_file: resultFileName });
+
+        // Spawn `palmier run <id>` directly as a detached process
+        const script = process.argv[1] || "palmier";
+        const child = spawn(process.execPath, [script, "run", id], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: true,
+        });
+        child.unref();
+
+        return { ok: true, task_id: id, result_file: resultFileName };
+      }
+
       case "task.run": {
         const params = request.params as { id: string };
         try {
+          // Create initial result file so it appears in runs list immediately
+          const runTaskDir = getTaskDir(config.projectRoot, params.id);
+          const runTask = parseTaskFile(runTaskDir);
+          const runResultFileName = createResultFile(runTaskDir, runTask.frontmatter.name, Date.now());
+          appendHistory(config.projectRoot, { task_id: params.id, result_file: runResultFileName });
+
           await getPlatform().startTask(params.id);
-          return { ok: true, task_id: params.id };
+          return { ok: true, task_id: params.id, result_file: runResultFileName };
         } catch (err: unknown) {
           const e = err as { stderr?: string; message?: string };
           console.error(`task.run failed for ${params.id}: ${e.stderr || e.message}`);

package/src/task.ts

@@ -147,6 +147,23 @@ export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   }
 }
 
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export function createResultFile(
+  taskDir: string,
+  taskName: string,
+  startTime: number,
+): string {
+  const resultFileName = `RESULT-${startTime}.md`;
+  const taskSnapshotName = `TASK-${startTime}.md`;
+  const content = `---\ntask_name: ${taskName}\nrunning_state: started\nstart_time: ${startTime}\ntask_file: ${taskSnapshotName}\n---\n`;
+  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+  return resultFileName;
+}
+
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/src/update-checker.ts

@@ -12,41 +12,6 @@ const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "
 export const isDevBuild = fs.existsSync(path.join(packageRoot, ".git"));
 export const currentVersion = isDevBuild ? `${pkg.version}-dev` : pkg.version;
 
-let latestVersion: string | null = null;
-let lastCheckTime = 0;
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-
-/**
- * Check the npm registry for the latest version of palmier.
- */
-export async function checkForUpdate(): Promise<void> {
-  if (isDevBuild) return;
-  const now = Date.now();
-  if (now - lastCheckTime < CHECK_INTERVAL_MS) return;
-  lastCheckTime = now;
-
-  try {
-    const res = await fetch("https://registry.npmjs.org/palmier/latest", {
-      signal: AbortSignal.timeout(10_000),
-    });
-    if (!res.ok) return;
-    const data = (await res.json()) as { version?: string };
-    if (data.version) {
-      latestVersion = data.version;
-      console.log(`[update] Latest version: ${data.version} (current: ${currentVersion})`);
-    }
-  } catch {
-    // Network errors are expected (offline, etc.)
-  }
-}
-
-/**
- * Get the latest version from npm, or null if not yet checked.
- */
-export function getLatestVersion(): string | null {
-  return latestVersion;
-}
-
 /**
  * Run the update and restart the daemon.
  * Returns an error message if the update fails.
@@ -63,7 +28,6 @@ export async function performUpdate(): Promise<string | null> {
       return `Update failed. Please run manually:\nnpm update -g palmier`;
     }
     console.log("[update] Update installed, restarting daemon...");
-    latestVersion = null;
     // Small delay to allow the RPC response to be sent
     setTimeout(() => {
       getPlatform().restartDaemon().catch((err) => {

package/src/user-input.ts

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import * as path from "path";
+import { readTaskStatus, writeTaskStatus } from "./task.js";
+import { publishHostEvent } from "./events.js";
+import type { HostConfig } from "./types.js";
+import type { NatsConnection } from "nats";
+
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export function waitForUserInput(taskDir: string): Promise<string[]> {
+  const statusPath = path.join(taskDir, "status.json");
+  return new Promise<string[]>((resolve) => {
+    const watcher = fs.watch(statusPath, () => {
+      const status = readTaskStatus(taskDir);
+      if (!status || !status.user_input?.length) return;
+      watcher.close();
+      resolve(status.user_input);
+    });
+  });
+}
+
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export async function requestUserInput(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  taskName: string,
+  taskDir: string,
+  inputDescriptions: string[],
+): Promise<string[] | "aborted"> {
+  const currentStatus = readTaskStatus(taskDir)!;
+  writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
+
+  await publishHostEvent(nc, config.hostId, taskId, {
+    event_type: "input-request",
+    host_id: config.hostId,
+    input_descriptions: inputDescriptions,
+    name: taskName,
+  });
+
+  const userInput = await waitForUserInput(taskDir);
+  if (userInput.length === 1 && userInput[0] === "aborted") {
+    writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
+    return "aborted";
+  }
+  writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
+  return userInput;
+}
+
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export async function publishInputResolved(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  status: "provided" | "aborted",
+): Promise<void> {
+  await publishHostEvent(nc, config.hostId, taskId, {
+    event_type: "input-resolved",
+    host_id: config.hostId,
+    status,
+  });
+}