palmier 0.5.1 → 0.5.2

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,6 +255,8 @@ 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",
@@ -250,18 +265,20 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                     name: task.frontmatter.name,
                 });
                 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 });
                 }

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.1",
+  "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) },
@@ -531,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/rpc-handler.ts

@@ -188,6 +188,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -218,6 +219,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             triggers: params.triggers ?? [],
             triggers_enabled: params.triggers_enabled ?? true,
             requires_confirmation: params.requires_confirmation ?? true,
+            ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
           body,
@@ -238,6 +240,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -256,6 +259,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         if (params.triggers_enabled !== undefined) existing.frontmatter.triggers_enabled = params.triggers_enabled;
         if (params.requires_confirmation !== undefined)
           existing.frontmatter.requires_confirmation = params.requires_confirmation;
+        if (params.yolo_mode !== undefined) existing.frontmatter.yolo_mode = params.yolo_mode || undefined;
         if (params.command !== undefined) {
           if (params.command) {
             existing.frontmatter.command = params.command;
@@ -302,6 +306,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           user_prompt: string;
           agent: string;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -317,6 +322,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             triggers: [],
             triggers_enabled: false,
             requires_confirmation: params.requires_confirmation ?? false,
+            ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
           body: "",
@@ -390,7 +396,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // Fire-and-forget: invoke agent inline as a child of the serve process
         const followupAgent = getAgent(followupTask.frontmatter.agent);
         const { command: cmd, args: cmdArgs, stdin } = followupAgent.getTaskRunCommandLine(
-          followupTask, params.message, followupTask.frontmatter.permissions,
+          followupTask, params.message, followupTask.frontmatter.yolo_mode ? "yolo" : followupTask.frontmatter.permissions,
         );
 
         // Spawn directly via crossSpawn so we can track and kill the child
@@ -564,8 +570,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const reports: Array<{ file: string; content?: string; error?: string }> = [];
         const runDir = path.join(config.projectRoot, "tasks", params.id, params.run_id);
         for (const file of params.report_files) {
-          if (!file.endsWith(".md")) {
-            reports.push({ file, error: "must end with .md" });
+          if (!file.endsWith(".md") && !file.endsWith(".txt")) {
+            reports.push({ file, error: "must end with .md or .txt" });
             continue;
           }
           const basename = path.basename(file);

package/src/task.ts

@@ -202,31 +202,66 @@ export function beginStreamingMessage(
   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 {
-  private delimiter: string;
-  constructor(private filePath: string, delimiter: string) {
-    this.delimiter = delimiter;
-  }
+  constructor(private filePath: string) {}
 
   /** Append a chunk of content to the current message. */
   write(chunk: string): void {
     fs.appendFileSync(this.filePath, chunk, "utf-8");
   }
 
-  /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+  /** Finalize the message. If attachments are provided, rewrites the last assistant delimiter to include them. */
   end(attachments?: string[]): void {
     fs.appendFileSync(this.filePath, "\n\n", "utf-8");
     if (attachments?.length) {
       const raw = fs.readFileSync(this.filePath, "utf-8");
-      const updated = raw.replace(this.delimiter, `${this.delimiter.slice(0, -4)} attachments="${attachments.join(",")}" -->`);
-      fs.writeFileSync(this.filePath, updated, "utf-8");
+      // 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: RegExpExecArray | null = 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: string,
+  runId: string,
+  userMsg: ConversationMessage,
+  /** Optional text to append to the current assistant block before ending it. */
+  assistantAppend?: string,
+): void {
+  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.
  */