palmier 0.5.0 → 0.5.2

package/dist/task.js

@@ -169,29 +169,61 @@ export function beginStreamingMessage(taskDir, runId, time) {
     const filePath = path.join(taskDir, runId, "TASKRUN.md");
     const delimiter = `<!-- palmier:message role="assistant" time="${time}" -->`;
     fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
-    return new StreamingMessageWriter(filePath, delimiter);
+    return new StreamingMessageWriter(filePath);
 }
 export class StreamingMessageWriter {
     filePath;
-    delimiter;
-    constructor(filePath, delimiter) {
+    constructor(filePath) {
         this.filePath = filePath;
-        this.delimiter = delimiter;
     }
     /** Append a chunk of content to the current message. */
     write(chunk) {
         fs.appendFileSync(this.filePath, chunk, "utf-8");
     }
-    /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+    /** Finalize the message. If attachments are provided, rewrites the last assistant delimiter to include them. */
     end(attachments) {
         fs.appendFileSync(this.filePath, "\n\n", "utf-8");
         if (attachments?.length) {
             const raw = fs.readFileSync(this.filePath, "utf-8");
-            const updated = raw.replace(this.delimiter, `${this.delimiter.slice(0, -4)} attachments="${attachments.join(",")}" -->`);
-            fs.writeFileSync(this.filePath, updated, "utf-8");
+            // Find the last assistant delimiter (may differ from the original if spliceUserMessage created a new one)
+            const pattern = /<!-- palmier:message role="assistant" time="\d+" -->/g;
+            let lastMatch = null;
+            let m;
+            while ((m = pattern.exec(raw)) !== null)
+                lastMatch = m;
+            if (lastMatch) {
+                const before = raw.slice(0, lastMatch.index);
+                const after = raw.slice(lastMatch.index + lastMatch[0].length);
+                const updated = before + `${lastMatch[0].slice(0, -4)} attachments="${attachments.join(",")}" -->` + after;
+                fs.writeFileSync(this.filePath, updated, "utf-8");
+            }
         }
     }
 }
+/**
+ * Splice a user message into a running assistant stream.
+ * Ends the current assistant block, writes the user message,
+ * then opens a new assistant block — all as direct file appends.
+ * The existing StreamingMessageWriter keeps working because its
+ * write() is just appendFileSync, so subsequent chunks land in
+ * the new assistant block.
+ */
+export function spliceUserMessage(taskDir, runId, userMsg, 
+/** Optional text to append to the current assistant block before ending it. */
+assistantAppend) {
+    const filePath = path.join(taskDir, runId, "TASKRUN.md");
+    // 1. Optionally append to the current assistant block (e.g. the input questions)
+    if (assistantAppend) {
+        fs.appendFileSync(filePath, assistantAppend, "utf-8");
+    }
+    // 2. End the current assistant block
+    fs.appendFileSync(filePath, "\n\n", "utf-8");
+    // 3. Write the user message
+    appendRunMessage(taskDir, runId, userMsg);
+    // 4. Open a new assistant block for subsequent agent output
+    const delimiter = `<!-- palmier:message role="assistant" time="${Date.now()}" -->`;
+    fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
+}
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

package/dist/transports/http-transport.js

@@ -3,7 +3,8 @@ import * as os from "os";
 import { StringCodec } from "nats";
 import { validateSession, addSession } from "../session-store.js";
 import { registerPending } from "../pending-requests.js";
-import { getTaskDir, parseTaskFile, appendRunMessage } from "../task.js";
+import * as fs from "node:fs";
+import { getTaskDir, parseTaskFile, spliceUserMessage } from "../task.js";
 const PWA_ORIGIN = "https://app.palmier.me";
 const assetCache = new Map();
 /** Paths currently being fetched (dedup concurrent requests). */
@@ -78,6 +79,18 @@ export function detectLanIp() {
     }
     return "127.0.0.1";
 }
+/** Find the latest (highest-numbered) run directory for a task. */
+function findLatestRunId(taskDir) {
+    try {
+        const dirs = fs.readdirSync(taskDir)
+            .filter((f) => /^\d+$/.test(f) && fs.statSync(`${taskDir}/${f}`).isDirectory())
+            .sort();
+        return dirs.length > 0 ? dirs[dirs.length - 1] : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Start the HTTP transport: server with RPC, SSE, PWA proxy, pairing, and
  * localhost-only agent endpoints (notify, request-input, confirmation, permission).
@@ -242,25 +255,30 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                 }
                 const taskDir = getTaskDir(config.projectRoot, taskId);
                 const task = parseTaskFile(taskDir);
+                // Resolve runId: use provided value, otherwise find the latest run directory
+                const effectiveRunId = runId ?? findLatestRunId(taskDir);
+                const pendingPromise = registerPending(taskId, "input", descriptions);
                 await publishEvent(taskId, {
                     event_type: "input-request",
                     host_id: config.hostId,
                     input_descriptions: descriptions,
                     name: task.frontmatter.name,
                 });
-                const response = await registerPending(taskId, "input", descriptions);
+                const response = await pendingPromise;
+                const questionsBlock = "\n\n" + descriptions.map((d) => `**${d}**`).join("\n");
                 if (response.length === 1 && response[0] === "aborted") {
                     await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "aborted" });
-                    if (runId) {
-                        appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Input request aborted.", type: "input" });
+                    if (effectiveRunId) {
+                        spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: "Aborted", type: "input" }, questionsBlock);
+                        await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
                     }
                     sendJson(res, 200, { aborted: true });
                 }
                 else {
                     await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "provided" });
-                    if (runId) {
-                        const lines = descriptions.map((desc, i) => `**${desc}** ${response[i]}`);
-                        appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: lines.join("\n"), type: "input" });
+                    if (effectiveRunId) {
+                        spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: response.join("\n"), type: "input" }, questionsBlock);
+                        await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
                     }
                     sendJson(res, 200, { values: response });
                 }
@@ -283,11 +301,12 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                     sendJson(res, 400, { error: "taskId is required" });
                     return;
                 }
+                const pendingPromise = registerPending(taskId, "confirmation");
                 await publishEvent(taskId, {
                     event_type: "confirm-request",
                     host_id: config.hostId,
                 });
-                const response = await registerPending(taskId, "confirmation");
+                const response = await pendingPromise;
                 const confirmed = response[0] === "confirmed";
                 await publishEvent(taskId, {
                     event_type: "confirm-resolved",
@@ -314,13 +333,14 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                     sendJson(res, 400, { error: "taskId and permissions are required" });
                     return;
                 }
+                const pendingPromise = registerPending(taskId, "permission", permissions);
                 await publishEvent(taskId, {
                     event_type: "permission-request",
                     host_id: config.hostId,
                     required_permissions: permissions,
                     name: taskName,
                 });
-                const response = await registerPending(taskId, "permission", permissions);
+                const response = await pendingPromise;
                 const status = response[0];
                 await publishEvent(taskId, {
                     event_type: "permission-resolved",

package/dist/types.d.ts

@@ -19,6 +19,7 @@ export interface TaskFrontmatter {
     triggers: Trigger[];
     triggers_enabled: boolean;
     requires_confirmation: boolean;
+    yolo_mode?: boolean;
     permissions?: RequiredPermission[];
     command?: string;
 }

package/package.json

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

package/src/agents/agent-instructions.md

@@ -2,23 +2,19 @@ You are an AI agent executing a task on behalf of the user via the Palmier platf
 
 ## Reporting Output
 
-If you generate report or output files, print each file path on its own line prefixed with [PALMIER_REPORT]:
-[PALMIER_REPORT] report.md
-[PALMIER_REPORT] summary.md
+If you generate report or output files, print each file path on its own line using this exact format (no code block):
+`[PALMIER_REPORT] <filename>`
 
 ## Completion
 
-When you are done, output exactly one of these markers as the very last line:
-- Success: [PALMIER_TASK_SUCCESS]
-- Failure: [PALMIER_TASK_FAILURE]
-Do not wrap them in code blocks or add text on the same line.
+When you are done, output exactly one of these markers as the very last line (no code block, no other text on the same line):
+- Success: `[PALMIER_TASK_SUCCESS]`
+- Failure: `[PALMIER_TASK_FAILURE]`
 
 ## Permissions
 
-If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]:
-[PALMIER_PERMISSION] Read | Read file contents from the repository
-[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
-[PALMIER_PERMISSION] Write | Write generated output files
+If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line using this exact format (no code block):
+`[PALMIER_PERMISSION] <tool_name> | <description>`
 
 ## HTTP Endpoints
 

package/src/agents/agent.ts

@@ -4,6 +4,8 @@ import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
 import { OpenClawAgent } from "./openclaw.js";
 import { CopilotAgent } from "./copilot.js";
+import { QwenAgent } from "./qwen.js";
+import { KimiAgent } from "./kimi.js";
 
 export interface CommandLine {
   command: string;
@@ -21,9 +23,14 @@ export interface AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine;
 
   /** Return the command and args used to run a task. If followupPrompt is provided, use it instead of the task's prompt,
-   *  and treat it as a continuation of the original run (reuse the same session, etc). extraPermissions are transient
-   *  permissions granted for this run only (not persisted in frontmatter). */
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+   *  and treat it as a continuation of the original run (reuse the same session, etc).
+   *  extraPermissions: pass an array of RequiredPermission for transient permissions granted for this run only,
+   *  or pass `"yolo"` to enable yolo mode (auto-approve all tools, skip permission instructions). */
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+
+  /** Whether this agent supports permission overrides (e.g. --allowedTools).
+   *  If false, the permissions section is omitted from agent instructions. */
+  supportsPermissions: boolean;
 
   /** Detect whether the agent CLI is available and perform any agent-specific
    *  initialization. Returns true if the agent was detected and initialized successfully. */
@@ -36,6 +43,8 @@ const agentRegistry: Record<string, AgentTool> = {
   codex: new CodexAgent(),
   openclaw: new OpenClawAgent(),
   copilot: new CopilotAgent(),
+  qwen: new QwenAgent(),
+  kimi: new KimiAgent(),
 };
 
 const agentLabels: Record<string, string> = {
@@ -44,11 +53,14 @@ const agentLabels: Record<string, string> = {
   codex: "Codex CLI",
   openclaw: "OpenClaw",
   copilot: "Copilot CLI",
+  qwen: "Qwen Code",
+  kimi: "Kimi Code",
 };
 
 export interface DetectedAgent {
   key: string;
   label: string;
+  supportsPermissions: boolean;
 }
 
 export async function detectAgents(): Promise<DetectedAgent[]> {
@@ -56,7 +68,7 @@ export async function detectAgents(): Promise<DetectedAgent[]> {
   for (const [key, agent] of Object.entries(agentRegistry)) {
     const label = agentLabels[key] ?? key;
     const ok = await agent.init();
-    if (ok) detected.push({ key, label });
+    if (ok) detected.push({ key, label, supportsPermissions: agent.supportsPermissions });
   }
   return detected;
 }

package/src/agents/claude.ts

@@ -5,6 +5,7 @@ import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 
 export class ClaudeAgent implements AgentTool {
+  supportsPermissions = true;
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "claude",
@@ -12,13 +13,17 @@ export class ClaudeAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-    const args = ["--permission-mode", "acceptEdits", "-p", "--allowedTools", "WebFetch"];
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["--permission-mode", yolo ? "bypassPermissions" : "acceptEdits", "-p"];
 
-    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-    for (const p of allPerms) {
-      args.push("--allowedTools", p.name);
+    if (!yolo) {
+      args.push("--allowedTools", "WebFetch");
+      const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+      for (const p of allPerms) {
+        args.push("--allowedTools", p.name);
+      }
     }
 
     if (followupPrompt) {args.push("-c");} // continue mode for followups

package/src/agents/codex.ts

@@ -5,6 +5,7 @@ import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 
 export class CodexAgent implements AgentTool {
+  supportsPermissions = true;
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "codex",
@@ -12,15 +13,18 @@ export class CodexAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
     // Using danger-full-access until workspace-write is fixed: https://github.com/openai/codex/issues/12572
-    const args = ["exec", "--full-auto", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
+    const args = ["exec", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
 
-    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-    for (const p of allPerms) {
-      args.push("--config");
-      args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
+    if (!yolo) {
+      const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+      for (const p of allPerms) {
+        args.push("--config");
+        args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
+      }
     }
     if (followupPrompt) {args.push("resume", "--last");} // continue mode for followups
     args.push("-"); // read prompt from stdin

package/src/agents/copilot.ts

@@ -5,6 +5,7 @@ import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 
 export class CopilotAgent implements AgentTool {
+  supportsPermissions = false;
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "copilot",
@@ -12,12 +13,17 @@ export class CopilotAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
     const args = ["-p", prompt];
 
-    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-    args.push(`--allow-tool=${["web_fetch", ...allPerms.map((p) => p.name)].join(",")}`);
+    if (yolo) {
+      args.push("--yolo");
+    } else {
+      const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+      args.push(`--allow-tool=${["web_fetch", ...allPerms.map((p) => p.name)].join(",")}`);
+    }
     if (followupPrompt) { args.push("--continue"); }
     return { command: "copilot", args};
   }

package/src/agents/gemini.ts

@@ -5,6 +5,7 @@ import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 
 export class GeminiAgent implements AgentTool {
+  supportsPermissions = true;
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "gemini",
@@ -12,21 +13,24 @@ export class GeminiAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-    const args = ["--approval-mode", "auto_edit", "--allowed-tools", "web_fetch"];
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["--approval-mode", yolo ? "yolo" : "auto_edit"];
 
-    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-    if (allPerms.length > 0) {
+    if (!yolo) {
+      const tools = ["run_shell_command", "web_fetch"];
+      const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
       for (const p of allPerms) {
-        args.push(p.name);
+        tools.push(p.name);
       }
+      args.push("--allowed-tools", tools.join(","));
     }
 
     if (followupPrompt) {args.push("--resume");} // continue mode for followups
-    args.push("--prompt", prompt);
+    args.push("--prompt", "-"); // read prompt from stdin to avoid command line length limits
     
-    return { command: "gemini", args };
+    return { command: "gemini", args, stdin: prompt };
   }
 
   async init(): Promise<boolean> {

package/src/agents/kimi.ts

@@ -0,0 +1,37 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class KimiAgent implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "kimi",
+      args: ["-p", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = [];
+
+    if (yolo) {
+      args.push("--yolo");
+    }
+    if (followupPrompt) { args.push("--continue"); }
+    args.push("-p", prompt);
+    return { command: "kimi", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("kimi --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/openclaw.ts

@@ -4,6 +4,7 @@ import type { AgentTool, CommandLine } from "./agent.js";
 import { getAgentInstructions } from "./shared-prompt.js";
 
 export class OpenClawAgent implements AgentTool {
+  supportsPermissions = false;
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "openclaw",
@@ -11,8 +12,9 @@ export class OpenClawAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
     // OpenClaw does not support stdin as prompt.
     const args = ["agent", "--local", "--session-id", task.frontmatter.id, "--message", prompt];
 

package/src/agents/qwen.ts

@@ -0,0 +1,34 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class QwenAgent implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "qwen",
+      args: ["-p", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["--approval-mode", yolo ? "yolo" : "auto-edit"];
+
+    if (followupPrompt) { args.push("-c"); }
+    args.push("-p", prompt);
+    return { command: "qwen", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("qwen --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/shared-prompt.ts

@@ -13,11 +13,15 @@ const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(
 /**
  * Agent instructions with the serve daemon's HTTP port and task ID baked in.
  */
-export function getAgentInstructions(taskId: string): string {
+export function getAgentInstructions(taskId: string, skipPermissions?: boolean): string {
   const port = loadConfig().httpPort ?? 7400;
-  return AGENT_INSTRUCTIONS_TEMPLATE
+  let instructions = AGENT_INSTRUCTIONS_TEMPLATE
     .replace(/\{\{PORT\}\}/g, String(port))
     .replace(/\{\{TASK_ID\}\}/g, taskId);
+  if (skipPermissions) {
+    instructions = instructions.replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
+  }
+  return instructions;
 }
 
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";

package/src/commands/run.ts

@@ -62,7 +62,12 @@ async function invokeAgentWithRetries(
       }, 500);
     }
 
-    const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.transientPermissions);
+    const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(
+      invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions,
+    );
+    const truncate = (s: string, max = 100) => s.length > max ? s.slice(0, max) + "…" : s;
+    const displayArgs = args.map((a) => truncate(a));
+    console.log(`[invoke] ${command} ${displayArgs.join(" ")}${stdin ? ` (stdin: ${truncate(stdin, 100)})` : ""}`);
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
       env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
@@ -454,7 +459,11 @@ async function requestPermission(
       permissions: requiredPermissions,
     }),
   });
-  const { response } = await res.json() as { response: "granted" | "granted_all" | "aborted" };
+  const body = await res.json() as { response?: string; error?: string };
+  const response = body.response as "granted" | "granted_all" | "aborted" | undefined;
+  if (!response || !["granted", "granted_all", "aborted"].includes(response)) {
+    throw new Error(`Permission request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+  }
   writeTaskStatus(taskDir, {
     running_state: response === "aborted" ? "aborted" : "started",
     time_stamp: Date.now(),
@@ -474,7 +483,11 @@ async function requestConfirmation(
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
   });
-  const { confirmed } = await res.json() as { confirmed: boolean };
+  const body = await res.json() as { confirmed?: boolean; error?: string };
+  if (typeof body.confirmed !== "boolean") {
+    throw new Error(`Confirmation request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
+  }
+  const { confirmed } = body;
   writeTaskStatus(taskDir, {
     running_state: confirmed ? "started" : "aborted",
     time_stamp: Date.now(),
@@ -523,8 +536,14 @@ export function parsePermissions(output: string): RequiredPermission[] {
  */
 export function parseTaskOutcome(output: string): TaskRunningState {
   const lastChunk = output.slice(-500);
-  if (lastChunk.includes(TASK_FAILURE_MARKER)) return "failed";
-  if (lastChunk.includes(TASK_SUCCESS_MARKER)) return "finished";
+  const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$`, "gm");
+  let last: string | null = null;
+  let match;
+  while ((match = regex.exec(lastChunk)) !== null) {
+    last = match[0];
+  }
+  if (last === TASK_FAILURE_MARKER) return "failed";
+  if (last === TASK_SUCCESS_MARKER) return "finished";
   return "finished";
 }
 

package/src/platform/windows.ts

@@ -127,7 +127,7 @@ export class WindowsPlatform implements PlatformService {
       process.exit(0);
     }
 
-    // Kill old daemon first, then spawn new one.
+    // Kill old daemon by PID
     if (oldPid) {
       try {
         execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
@@ -136,6 +136,19 @@ export class WindowsPlatform implements PlatformService {
       }
     }
 
+    // Also kill any stale palmier serve processes (e.g. leftover from a previous daemon)
+    try {
+      const out = execFileSync("wmic", ["process", "where", `CommandLine like '%palmier%serve%' and ProcessId != '${process.pid}'`, "get", "ProcessId"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
+      for (const line of out.split("\n")) {
+        const pid = line.trim();
+        if (pid && /^\d+$/.test(pid)) {
+          try { execFileSync("taskkill", ["/pid", pid, "/f", "/t"], { windowsHide: true, stdio: "pipe" }); } catch {}
+        }
+      }
+    } catch {
+      // wmic may not be available on all Windows versions
+    }
+
     this.startDaemonTask();
   }