palmier 1.1.20 → 1.1.22

package/README.md

@@ -182,7 +182,7 @@ The wizard:
 - Offers to install the **Playwright CLI** for browser automation (see [Browser Automation](#browser-automation)). Skipped on re-init if it's already managed.
 - Asks for the HTTP port
 - Detects the default network interface (used for auto-LAN)
-- Shows a summary (including any existing scheduled tasks to recover) and asks for confirmation
+- Shows a summary (including the Palmier daemon version and any existing scheduled tasks to recover) and asks for confirmation
 - Registers with the Palmier server, saves configuration to `~/.config/palmier/host.json`
 - Installs a background daemon (systemd user service on Linux, LaunchAgent on macOS, Task Scheduler on Windows). On re-init, also restarts the daemon so the running process picks up the new agents/versions for `host.info`.
 - Auto-enters pair mode to connect your first device

package/dist/agent-tools.d.ts

@@ -1,4 +1,4 @@
-import { type NatsConnection } from "nats";
+import { type NatsConnection } from "@nats-io/transport-node";
 import type { HostConfig } from "./types.js";
 export declare class ToolError extends Error {
     statusCode: number;

package/dist/agent-tools.js

@@ -1,4 +1,3 @@
-import { StringCodec } from "nats";
 import { registerPending } from "./pending-requests.js";
 import { getLinkedDevice } from "./linked-device.js";
 import { getNotifications } from "./notification-store.js";
@@ -33,11 +32,10 @@ const notifyTool = {
             throw new ToolError("title and body are required", 400);
         if (!ctx.nc)
             throw new ToolError("NATS not connected — push notifications require server mode", 503);
-        const sc = StringCodec();
         const payload = { hostId: ctx.config.hostId, title, body, session_id: ctx.taskId };
         const subject = `host.${ctx.config.hostId}.push.send`;
-        const reply = await ctx.nc.request(subject, sc.encode(JSON.stringify(payload)), { timeout: 15_000 });
-        const result = JSON.parse(sc.decode(reply.data));
+        const reply = await ctx.nc.request(subject, JSON.stringify(payload), { timeout: 15_000 });
+        const result = JSON.parse(reply.string());
         if (result.ok)
             return { ok: true };
         throw new ToolError(result.error ?? "Push notification failed", 502);
@@ -309,9 +307,8 @@ const deviceGeolocationTool = {
         const device = getLinkedDevice();
         if (!device)
             throw new ToolError("No linked device configured", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.geolocation`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.geolocation`, JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const locationPromise = new Promise((resolve, reject) => {
@@ -323,7 +320,7 @@ const deviceGeolocationTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -350,9 +347,8 @@ const readContactsTool = {
         const device = getLinkedDevice();
         if (!device)
             throw new ToolError("No linked device configured", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, action: "read" })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, action: "read" }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -364,7 +360,7 @@ const readContactsTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -399,12 +395,11 @@ const createContactTool = {
         const { name, phone, email } = args;
         if (!name)
             throw new ToolError("name is required", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, sc.encode(JSON.stringify({
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, JSON.stringify({
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "create", name, phone, email,
-        })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -416,7 +411,7 @@ const createContactTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -448,14 +443,13 @@ const readCalendarTool = {
         if (!device)
             throw new ToolError("No linked device configured", 400);
         const { startDate, endDate } = args;
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.calendar`, sc.encode(JSON.stringify({
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.calendar`, JSON.stringify({
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "read",
             ...(startDate ? { startDate: String(startDate) } : {}),
             ...(endDate ? { endDate: String(endDate) } : {}),
-        })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -467,7 +461,7 @@ const readCalendarTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -504,15 +498,14 @@ const createCalendarEventTool = {
         const { title, startTime, endTime, location, description } = args;
         if (!title || !startTime || !endTime)
             throw new ToolError("title, startTime, and endTime are required", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.calendar`, sc.encode(JSON.stringify({
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.calendar`, JSON.stringify({
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "create",
             title, startTime: String(startTime), endTime: String(endTime),
             ...(location ? { location } : {}),
             ...(description ? { description } : {}),
-        })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -524,7 +517,7 @@ const createCalendarEventTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -558,12 +551,11 @@ const sendSmsTool = {
         const { to, body } = args;
         if (!to || !body)
             throw new ToolError("to and body are required", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.sms`, sc.encode(JSON.stringify({
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.sms`, JSON.stringify({
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "send", to, body,
-        })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -575,7 +567,7 @@ const sendSmsTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -610,15 +602,14 @@ const sendAlarmTool = {
         const { title, description } = args;
         if (!title)
             throw new ToolError("title is required", 400);
-        const sc = StringCodec();
         const payload = {
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             title,
         };
         if (description)
             payload.description = description;
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.alarm`, sc.encode(JSON.stringify(payload)), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.alarm`, JSON.stringify(payload), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -630,7 +621,7 @@ const sendAlarmTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -657,9 +648,8 @@ const readBatteryTool = {
         const device = getLinkedDevice();
         if (!device)
             throw new ToolError("No linked device configured", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.battery`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.battery`, JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -671,7 +661,7 @@ const readBatteryTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -704,9 +694,8 @@ const setRingerModeTool = {
         const { mode } = args;
         if (!["normal", "vibrate", "silent"].includes(mode))
             throw new ToolError("mode must be 'normal', 'vibrate', or 'silent'", 400);
-        const sc = StringCodec();
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.ringer`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, mode })), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.ringer`, JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, mode }), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -718,7 +707,7 @@ const setRingerModeTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });
@@ -755,7 +744,6 @@ const sendEmailTool = {
         const { to, subject, body, cc, bcc } = args;
         if (!to)
             throw new ToolError("to is required", 400);
-        const sc = StringCodec();
         const payload = {
             hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             to,
@@ -768,8 +756,8 @@ const sendEmailTool = {
             payload.cc = cc;
         if (bcc)
             payload.bcc = bcc;
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.email`, sc.encode(JSON.stringify(payload)), { timeout: 5_000 });
-        const ack = JSON.parse(sc.decode(ackReply.data));
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.email`, JSON.stringify(payload), { timeout: 5_000 });
+        const ack = JSON.parse(ackReply.string());
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
@@ -781,7 +769,7 @@ const sendEmailTool = {
             (async () => {
                 for await (const msg of sub) {
                     clearTimeout(timer);
-                    resolve(sc.decode(msg.data));
+                    resolve(msg.string());
                 }
             })();
         });

package/dist/agents/agent-instructions.md

@@ -29,7 +29,9 @@ Whenever a tool you are trying to use is denied or you lack the required permiss
 
 ## Browsers
 
-When launching a browser with the Playwright CLI `open` command, always pass `--headed` (never run headless) and `--persistent` (reuse a persistent profile so logins and cookies survive across runs).
+Whenever the task needs a browser, launch it with the Playwright CLI (`playwright-cli open`). Do not use any other browser tool, automation library, or launch method.
+
+When launching, always pass `--headed` (never run headless) and `--persistent` (reuse a persistent profile so logins and cookies survive across runs).
 
 When the task is finished, close any browser you opened with the Playwright CLI `close` command (pass the same `-s=<session>` if you used one) before printing the completion marker.
 

package/dist/agents/agent.d.ts

@@ -30,7 +30,7 @@ export interface AgentTool {
     supportsPermissions?: boolean;
     /** Whether this agent supports yolo mode (auto-approve all tools). */
     supportsYolo?: boolean;
-    /** When true, the run loop will not persist the agent's stderr output. */
+    /** When true, the run loop persists the agent's stderr output only if the invocation fails. */
     suppressStdErr?: boolean;
     /** Matches the model name (capture group 1) in the banner the CLI prints on stderr.
      *  Takes precedence over the agent's self-reported model marker. */

package/dist/commands/init.js

@@ -10,6 +10,7 @@ import { getPlatform } from "../platform/index.js";
 import { pairCommand } from "./pair.js";
 import { detectDefaultInterface, getInterfaceIpv4 } from "../network.js";
 import { listTasks, taskDisplayName } from "../task.js";
+import { currentVersion } from "../update-checker.js";
 const { bold, dim, green, cyan, red } = colors;
 export async function initCommand() {
     console.log(`\n${bold("=== Palmier Host Setup ===")}\n`);
@@ -74,6 +75,7 @@ export async function initCommand() {
         const defaultInterface = (await detectDefaultInterface()) ?? undefined;
         const lanIp = defaultInterface ? getInterfaceIpv4(defaultInterface) : null;
         console.log(`\n${bold("Setup summary:")}\n`);
+        console.log(`  ${dim("Daemon:")}         Palmier v${currentVersion}\n`);
         console.log(`  ${dim("Task storage:")}   ${bold(projectRoot)}`);
         console.log(`                  All tasks and execution data will be stored here.\n`);
         console.log(`  ${dim("Local:")}          ${cyan(`http://localhost:${httpPort}`)}`);

package/dist/commands/pair.js

@@ -1,6 +1,5 @@
 import * as http from "node:http";
 import * as os from "node:os";
-import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { addClient } from "../client-store.js";
@@ -66,7 +65,6 @@ export async function pairCommand() {
     console.log("");
     console.log("Code expires in 1 minute.");
     const nc = await connectNats(config);
-    const sc = StringCodec();
     const subject = `pair.${code}`;
     const sub = nc.subscribe(subject, { max: 1 });
     cleanups.push(() => {
@@ -80,14 +78,14 @@ export async function pairCommand() {
             let label;
             try {
                 if (msg.data && msg.data.length > 0) {
-                    const body = JSON.parse(sc.decode(msg.data));
+                    const body = JSON.parse(msg.string());
                     label = body.label;
                 }
             }
             catch { /* empty body is fine */ }
             const response = buildPairResponse(config, label);
             if (msg.reply) {
-                msg.respond(sc.encode(JSON.stringify(response)));
+                msg.respond(JSON.stringify(response));
             }
             onPaired();
         }

package/dist/commands/run.js

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
-import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
+import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_PERMISSION_PREFIX, AGENT_MODEL_PREFIX } from "../agents/shared-prompt.js";
@@ -19,6 +19,7 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
         let writer;
         let activeStream;
         const lineBufs = { stdout: "", stderr: "" };
+        let suppressedStderr = "";
         let notifyPending = false;
         let notifyTimer;
         let agentModel;
@@ -50,7 +51,9 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             throttledNotify();
         }
         function onStderr(chunk) {
-            if (!ctx.agent.suppressStdErr)
+            if (ctx.agent.suppressStdErr)
+                suppressedStderr += chunk;
+            else
                 emit("stderr", chunk);
             const cliModel = captureCliModel(chunk);
             if (cliModel && !agentModelWritten)
@@ -71,6 +74,12 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             }
             flushAgentModel();
         }
+        function flushTrailingLine(stream) {
+            const trailing = lineBufs[stream];
+            if (trailing && !trailing.startsWith("[PALMIER")) {
+                ensureWriter(stream).write(trailing);
+            }
+        }
         const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions);
         const command = ctx.agent.command;
         const runDir = getRunDir(ctx.taskDir, ctx.runId);
@@ -87,21 +96,19 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             onStdout: (chunk) => emit("stdout", chunk),
             onStderr,
         });
-        if (notifyTimer)
-            clearTimeout(notifyTimer);
         const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
         const linkedFiles = listLinkedTaskFiles(ctx.taskDir, ctx.runId, result.output);
         const requiredPermissions = parsePermissions(result.output);
-        for (const stream of ["stdout", "stderr"]) {
-            const trailing = lineBufs[stream];
-            if (trailing && !trailing.startsWith("[PALMIER")) {
-                ensureWriter(stream).write(trailing);
-            }
-        }
+        flushTrailingLine("stdout");
+        if (outcome === "failed")
+            emit("stderr", suppressedStderr);
+        flushTrailingLine("stderr");
         if (requiredPermissions.length > 0) {
             const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
             ensureWriter("stdout").write(`\n\n**Permissions requested:**\n${permLines}\n`);
         }
+        if (notifyTimer)
+            clearTimeout(notifyTimer);
         writer?.end();
         await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
         if (linkedFiles.length > 0) {
@@ -154,18 +161,6 @@ async function appendAndNotify(ctx, msg) {
     appendRunMessage(ctx.taskDir, ctx.runId, msg);
     await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
-/** The latest run dir with no status messages yet — freshly created by the RPC handler. */
-function findLatestPendingRunId(taskDir) {
-    const dirs = fs.readdirSync(taskDir)
-        .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
-        .sort();
-    if (dirs.length === 0)
-        return null;
-    const latest = dirs[dirs.length - 1];
-    const messages = readRunMessages(taskDir, latest);
-    const hasStatus = messages.some((m) => m.role === "status");
-    return hasStatus ? null : latest;
-}
 /**
  * If the RPC handler already wrote "aborted" (via task.abort), respect that
  * instead of overwriting with the process's own outcome.
@@ -182,7 +177,7 @@ export async function runCommand(taskId) {
     const task = parseTaskFile(taskDir);
     console.log(`Running task: ${taskId}`);
     const taskName = taskDisplayName(task.frontmatter);
-    const existingRunId = findLatestPendingRunId(taskDir);
+    const existingRunId = claimPendingRun(taskDir);
     const agentVersion = config.agents?.find((a) => a.key === task.frontmatter.agent)?.version;
     const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now(), task.frontmatter.agent, agentVersion);
     if (!existingRunId) {

package/dist/commands/serve.js

@@ -12,7 +12,6 @@ import { detectAgents } from "../agents/agent.js";
 import { getPlaywrightCliVersion } from "../playwright-cli.js";
 import { saveConfig } from "../config.js";
 import { CONFIG_DIR } from "../config.js";
-import { StringCodec } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
 import { dispatchTrigger } from "../trigger-dispatch.js";
@@ -118,13 +117,13 @@ export async function serveCommand() {
         console.log("[nats] Connected");
         (async () => {
             for await (const s of conn.status()) {
-                if (s.type === "pingTimer")
+                if (s.type === "ping")
                     continue;
-                console.log(`[nats] Status: ${s.type}${typeof s.data === "string" ? ` (${s.data})` : ""}`);
+                const detail = "server" in s ? s.server : "error" in s ? s.error.message : undefined;
+                console.log(`[nats] Status: ${s.type}${detail ? ` (${detail})` : ""}`);
             }
         })();
         startNatsTransport(config, handleRpc, conn);
-        const sc = StringCodec();
         // Match phone numbers regardless of formatting; letters preserved for shortcodes.
         function normalizeSender(raw) {
             return raw.replace(/[\s\-()+]/g, "").toLowerCase();
@@ -152,7 +151,7 @@ export async function serveCommand() {
         const notifSub = conn.subscribe(`host.${config.hostId}.device.notifications`);
         (async () => {
             for await (const msg of notifSub) {
-                const raw = sc.decode(msg.data);
+                const raw = msg.string();
                 let parsed;
                 try {
                     parsed = JSON.parse(raw);
@@ -167,7 +166,7 @@ export async function serveCommand() {
         const smsSub = conn.subscribe(`host.${config.hostId}.device.sms`);
         (async () => {
             for await (const msg of smsSub) {
-                const raw = sc.decode(msg.data);
+                const raw = msg.string();
                 let parsed;
                 try {
                     parsed = JSON.parse(raw);

package/dist/nats-client.d.ts

@@ -1,3 +1,3 @@
-import { type NatsConnection } from "nats";
+import { type NatsConnection } from "@nats-io/transport-node";
 import type { HostConfig } from "./types.js";
 export declare function connectNats(config: HostConfig): Promise<NatsConnection>;

package/dist/nats-client.js

@@ -1,4 +1,4 @@
-import { connect, jwtAuthenticator } from "nats";
+import { connect, jwtAuthenticator } from "@nats-io/transport-node";
 export async function connectNats(config) {
     if (!config.natsJwt || !config.natsNkeySeed) {
         throw new Error("NATS JWT credentials not configured. Re-run palmier init.");

package/dist/rpc-handler.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-import { listTasks, parseTaskFile, taskDisplayName, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, isTaskInList, appendHistory, createRunDir, appendRunMessage, getRunDir, writeFollowupStatus, readFollowupStatus, deleteFollowupStatus, isRunStarred, setRunStarred, formatAgentModelComment, extractAgentModelComment } from "./task.js";
+import { listTasks, parseTaskFile, taskDisplayName, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, isTaskInList, createPendingRun, readPendingRun, appendRunMessage, getRunDir, writeFollowupStatus, readFollowupStatus, deleteFollowupStatus, isRunStarred, setRunStarred, formatAgentModelComment, extractAgentModelComment } from "./task.js";
 import { resolvePending, getPending, listPending } from "./pending-requests.js";
 import { getPlatform } from "./platform/index.js";
 import { onChildDone, resolveCommand, spawnCommand } from "./spawn-command.js";
@@ -136,6 +136,8 @@ async function generateName(projectRoot, userPrompt, agentName) {
         return userPrompt;
     }
 }
+// Longer than the slowest observed launch (~5s on Windows) before the run process claims its run.
+const DUPLICATE_RUN_WINDOW_MS = 15_000;
 /** Active follow-up child processes, keyed by "taskId:runId". */
 const activeFollowups = new Map();
 /**
@@ -364,8 +366,7 @@ export function createRpcHandler(config) {
                 writeTaskFile(taskDir, task);
                 // One-off run: do NOT append to tasks.jsonl.
                 const oneoffAgentVersion = config.agents?.find((a) => a.key === params.agent)?.version;
-                const runId = createRunDir(taskDir, name, Date.now(), params.agent, oneoffAgentVersion);
-                appendHistory(config.projectRoot, { task_id: id, run_id: runId });
+                const runId = createPendingRun(config.projectRoot, taskDir, id, name, params.agent, oneoffAgentVersion);
                 const platform = getPlatform();
                 platform.installTaskTimer(config, task);
                 try {
@@ -382,17 +383,22 @@ export function createRpcHandler(config) {
             case "task.run": {
                 const params = request.params;
                 const runTaskDir = getTaskDir(config.projectRoot, params.id);
+                const launchingRunId = readPendingRun(runTaskDir);
+                if (launchingRunId && Date.now() - Number(launchingRunId) < DUPLICATE_RUN_WINDOW_MS) {
+                    console.log(`[task.run] Task ${params.id} run ${launchingRunId} is still launching, ignoring duplicate request`);
+                    return { ok: true, task_id: params.id, run_id: launchingRunId };
+                }
                 let taskRunId;
                 try {
                     const platform = getPlatform();
+                    // Must stay synchronous up to here so a concurrent duplicate sees the pending run.
+                    const runTask = parseTaskFile(runTaskDir);
+                    const taskRunAgentVersion = config.agents?.find((a) => a.key === runTask.frontmatter.agent)?.version;
+                    taskRunId = createPendingRun(config.projectRoot, runTaskDir, params.id, taskDisplayName(runTask.frontmatter), runTask.frontmatter.agent, taskRunAgentVersion);
                     if (platform.isTaskRunning(params.id)) {
                         console.log(`[task.run] Task ${params.id} is already running, killing stale process`);
                         await platform.stopTask(params.id);
                     }
-                    const runTask = parseTaskFile(runTaskDir);
-                    const taskRunAgentVersion = config.agents?.find((a) => a.key === runTask.frontmatter.agent)?.version;
-                    taskRunId = createRunDir(runTaskDir, taskDisplayName(runTask.frontmatter), Date.now(), runTask.frontmatter.agent, taskRunAgentVersion);
-                    appendHistory(config.projectRoot, { task_id: params.id, run_id: taskRunId });
                     await platform.startTask(params.id);
                     return { ok: true, task_id: params.id, run_id: taskRunId };
                 }

package/dist/task.d.ts

@@ -21,6 +21,16 @@ export declare function isRunStarred(runDir: string): boolean;
 export declare function setRunStarred(runDir: string, starred: boolean): void;
 /** Returns the run ID (timestamp string used as directory name). */
 export declare function createRunDir(taskDir: string, taskName: string, startTime: number, agent?: string, agentVersion?: string): string;
+/** The run dir created for the next run process that it has not claimed yet, or null. */
+export declare function readPendingRun(taskDir: string): string | null;
+/**
+ * Create a run dir (plus its history entry) for the run process about to be
+ * launched to claim. A previous pending run that was never claimed is discarded
+ * so it doesn't linger as an empty session.
+ */
+export declare function createPendingRun(projectRoot: string, taskDir: string, taskId: string, taskName: string, agent?: string, agentVersion?: string): string;
+/** Take ownership of the pending run; null if there is none or another process took it first. */
+export declare function claimPendingRun(taskDir: string): string | null;
 export declare function getRunDir(taskDir: string, runId: string): string;
 export declare function appendRunMessage(taskDir: string, runId: string, msg: ConversationMessage): void;
 export declare function beginStreamingMessage(taskDir: string, runId: string, time: number, stream?: "stdout" | "stderr"): StreamingMessageWriter;

package/dist/task.js

@@ -155,6 +155,48 @@ export function createRunDir(taskDir, taskName, startTime, agent, agentVersion)
     fs.writeFileSync(path.join(runDir, "TASKRUN.md"), content, "utf-8");
     return runId;
 }
+const PENDING_RUN_FILE = "pending-run";
+function isUnclaimedRun(taskDir, runId) {
+    if (!/^\d+$/.test(runId) || !fs.existsSync(path.join(taskDir, runId, "TASKRUN.md")))
+        return false;
+    return !readRunMessages(taskDir, runId).some((m) => m.role === "status");
+}
+/** The run dir created for the next run process that it has not claimed yet, or null. */
+export function readPendingRun(taskDir) {
+    let runId;
+    try {
+        runId = fs.readFileSync(path.join(taskDir, PENDING_RUN_FILE), "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+    return isUnclaimedRun(taskDir, runId) ? runId : null;
+}
+/**
+ * Create a run dir (plus its history entry) for the run process about to be
+ * launched to claim. A previous pending run that was never claimed is discarded
+ * so it doesn't linger as an empty session.
+ */
+export function createPendingRun(projectRoot, taskDir, taskId, taskName, agent, agentVersion) {
+    const stale = readPendingRun(taskDir);
+    if (stale)
+        deleteHistoryEntry(projectRoot, taskId, stale);
+    const runId = createRunDir(taskDir, taskName, Date.now(), agent, agentVersion);
+    appendHistory(projectRoot, { task_id: taskId, run_id: runId });
+    fs.writeFileSync(path.join(taskDir, PENDING_RUN_FILE), runId, "utf-8");
+    return runId;
+}
+/** Take ownership of the pending run; null if there is none or another process took it first. */
+export function claimPendingRun(taskDir) {
+    const runId = readPendingRun(taskDir);
+    try {
+        fs.unlinkSync(path.join(taskDir, PENDING_RUN_FILE));
+    }
+    catch {
+        return null;
+    }
+    return runId;
+}
 export function getRunDir(taskDir, runId) {
     return path.join(taskDir, runId);
 }

package/dist/transports/http-transport.d.ts

@@ -1,3 +1,3 @@
-import { type NatsConnection } from "nats";
+import { type NatsConnection } from "@nats-io/transport-node";
 import type { HostConfig, RpcMessage } from "../types.js";
 export declare function startHttpTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, port: number, getNc: () => NatsConnection | undefined, pairingCode?: string, onReady?: () => void): Promise<void>;

package/dist/transports/http-transport.js

@@ -1,7 +1,6 @@
 import * as http from "node:http";
 import * as os from "os";
 import * as path from "node:path";
-import { StringCodec } from "nats";
 import { validateClient, addClient } from "../client-store.js";
 import { registerPending } from "../pending-requests.js";
 import * as fs from "node:fs";
@@ -106,9 +105,8 @@ export async function startHttpTransport(config, handleRpc, port, getNc, pairing
         return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
     }
     async function publishEvent(taskId, payload) {
-        const sc = StringCodec();
         const subject = `host-event.${config.hostId}.${taskId}`;
-        getNc()?.publish(subject, sc.encode(JSON.stringify(payload)));
+        getNc()?.publish(subject, JSON.stringify(payload));
         broadcastSseEvent({ task_id: taskId, ...payload });
     }
     function makeToolContext(taskId) {

package/dist/transports/nats-transport.d.ts

@@ -1,3 +1,3 @@
-import { type NatsConnection } from "nats";
+import { type NatsConnection } from "@nats-io/transport-node";
 import type { HostConfig, RpcMessage } from "../types.js";
 export declare function startNatsTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, nc: NatsConnection): Promise<void>;

package/dist/transports/nats-transport.js

@@ -1,6 +1,4 @@
-import { StringCodec } from "nats";
 export async function startNatsTransport(config, handleRpc, nc) {
-    const sc = StringCodec();
     const subject = `host.${config.hostId}.rpc.>`;
     console.log(`[nats] Subscribing to: ${subject}`);
     const sub = nc.subscribe(subject);
@@ -19,7 +17,7 @@ export async function startNatsTransport(config, handleRpc, nc) {
         const method = rpcIdx >= 0 ? subjectTokens.slice(rpcIdx + 1).join(".") : "";
         let params = {};
         if (msg.data && msg.data.length > 0) {
-            const raw = sc.decode(msg.data).trim();
+            const raw = msg.string().trim();
             if (raw.length > 0) {
                 try {
                     params = JSON.parse(raw);
@@ -27,7 +25,7 @@ export async function startNatsTransport(config, handleRpc, nc) {
                 catch {
                     console.error(`[nats] Failed to parse RPC params for ${method}`);
                     if (msg.reply) {
-                        msg.respond(sc.encode(JSON.stringify({ error: "Invalid JSON" })));
+                        msg.respond(JSON.stringify({ error: "Invalid JSON" }));
                     }
                     return;
                 }
@@ -47,7 +45,7 @@ export async function startNatsTransport(config, handleRpc, nc) {
         }
         console.log(`[nats] RPC done: ${method}`, JSON.stringify(response).slice(0, 200));
         if (msg.reply) {
-            msg.respond(sc.encode(JSON.stringify(response)));
+            msg.respond(JSON.stringify(response));
         }
     }
     async function consumeSubscription(subscription) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",
@@ -36,10 +36,10 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
+    "@nats-io/transport-node": "^3.4.0",
     "commander": "^13.1.0",
     "cross-spawn": "^7.0.6",
     "dotenv": "^16.4.7",
-    "nats": "^2.29.1",
     "yaml": "^2.7.0"
   },
   "devDependencies": {