palmier 0.5.1 → 0.5.2

package/dist/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/dist/agents/agent.d.ts

@@ -13,9 +13,13 @@ export interface AgentTool {
     /** Return the command and args used to generate a plan from a prompt. */
     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. */
     init(): Promise<boolean>;
@@ -23,6 +27,7 @@ export interface AgentTool {
 export interface DetectedAgent {
     key: string;
     label: string;
+    supportsPermissions: boolean;
 }
 export declare function detectAgents(): Promise<DetectedAgent[]>;
 export declare function getAgent(name: string): AgentTool;

package/dist/agents/agent.js

@@ -3,12 +3,16 @@ 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";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
     codex: new CodexAgent(),
     openclaw: new OpenClawAgent(),
     copilot: new CopilotAgent(),
+    qwen: new QwenAgent(),
+    kimi: new KimiAgent(),
 };
 const agentLabels = {
     claude: "Claude Code",
@@ -16,6 +20,8 @@ const agentLabels = {
     codex: "Codex CLI",
     openclaw: "OpenClaw",
     copilot: "Copilot CLI",
+    qwen: "Qwen Code",
+    kimi: "Kimi Code",
 };
 export async function detectAgents() {
     const detected = [];
@@ -23,7 +29,7 @@ export async function detectAgents() {
         const label = agentLabels[key] ?? key;
         const ok = await agent.init();
         if (ok)
-            detected.push({ key, label });
+            detected.push({ key, label, supportsPermissions: agent.supportsPermissions });
     }
     return detected;
 }

package/dist/agents/claude.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class ClaudeAgent implements AgentTool {
+    supportsPermissions: boolean;
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=claude.d.ts.map

package/dist/agents/claude.js

@@ -2,6 +2,7 @@ import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 export class ClaudeAgent {
+    supportsPermissions = true;
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "claude",
@@ -9,11 +10,15 @@ export class ClaudeAgent {
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-        const args = ["--permission-mode", "acceptEdits", "-p", "--allowedTools", "WebFetch"];
-        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-        for (const p of allPerms) {
-            args.push("--allowedTools", p.name);
+        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"];
+        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");

package/dist/agents/codex.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class CodexAgent implements AgentTool {
+    supportsPermissions: boolean;
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=codex.d.ts.map

package/dist/agents/codex.js

@@ -2,6 +2,7 @@ import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 export class CodexAgent {
+    supportsPermissions = true;
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "codex",
@@ -9,13 +10,16 @@ export class CodexAgent {
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+        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 allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-        for (const p of allPerms) {
-            args.push("--config");
-            args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
+        const args = ["exec", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
+        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");

package/dist/agents/copilot.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class CopilotAgent implements AgentTool {
+    supportsPermissions: boolean;
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=copilot.d.ts.map

package/dist/agents/copilot.js

@@ -2,6 +2,7 @@ import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 export class CopilotAgent {
+    supportsPermissions = false;
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "copilot",
@@ -9,10 +10,16 @@ export class CopilotAgent {
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+        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");
         }

package/dist/agents/gemini.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class GeminiAgent implements AgentTool {
+    supportsPermissions: boolean;
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=gemini.d.ts.map

package/dist/agents/gemini.js

@@ -2,6 +2,7 @@ import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 export class GeminiAgent {
+    supportsPermissions = true;
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "gemini",
@@ -9,19 +10,22 @@ export class GeminiAgent {
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
-        const args = ["--approval-mode", "auto_edit", "--allowed-tools", "web_fetch"];
-        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-        if (allPerms.length > 0) {
+        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 (!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);
-        return { command: "gemini", args };
+        args.push("--prompt", "-"); // read prompt from stdin to avoid command line length limits
+        return { command: "gemini", args, stdin: prompt };
     }
     async init() {
         try {

package/dist/agents/kimi.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class KimiAgent implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=kimi.d.ts.map

package/dist/agents/kimi.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class KimiAgent {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "kimi",
+            args: ["-p", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("kimi --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=kimi.js.map

package/dist/agents/openclaw.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class OpenClawAgent implements AgentTool {
+    supportsPermissions: boolean;
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=openclaw.d.ts.map

package/dist/agents/openclaw.js

@@ -1,6 +1,7 @@
 import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
 export class OpenClawAgent {
+    supportsPermissions = false;
     getPlanGenerationCommandLine(prompt) {
         return {
             command: "openclaw",
@@ -8,7 +9,8 @@ export class OpenClawAgent {
         };
     }
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
-        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+        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];
         return { command: "openclaw", args };

package/dist/agents/qwen.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class QwenAgent implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=qwen.d.ts.map

package/dist/agents/qwen.js

@@ -0,0 +1,32 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class QwenAgent {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "qwen",
+            args: ["-p", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("qwen --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=qwen.js.map

package/dist/agents/shared-prompt.d.ts

@@ -1,7 +1,7 @@
 /**
  * Agent instructions with the serve daemon's HTTP port and task ID baked in.
  */
-export declare function getAgentInstructions(taskId: string): string;
+export declare function getAgentInstructions(taskId: string, skipPermissions?: boolean): string;
 export declare const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export declare const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
 export declare const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";

package/dist/agents/shared-prompt.js

@@ -7,11 +7,15 @@ const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(path.join(__dirname, "agent-
 /**
  * Agent instructions with the serve daemon's HTTP port and task ID baked in.
  */
-export function getAgentInstructions(taskId) {
+export function getAgentInstructions(taskId, skipPermissions) {
     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]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";

package/dist/commands/run.js

@@ -33,7 +33,10 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
                 publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
             }, 500);
         }
-        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.transientPermissions);
+        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions);
+        const truncate = (s, 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) },
@@ -442,9 +445,15 @@ export function parsePermissions(output) {
  */
 export function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
-    if (lastChunk.includes(TASK_FAILURE_MARKER))
+    const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$`, "gm");
+    let last = null;
+    let match;
+    while ((match = regex.exec(lastChunk)) !== null) {
+        last = match[0];
+    }
+    if (last === TASK_FAILURE_MARKER)
         return "failed";
-    if (lastChunk.includes(TASK_SUCCESS_MARKER))
+    if (last === TASK_SUCCESS_MARKER)
         return "finished";
     return "finished";
 }

package/dist/rpc-handler.js

@@ -183,6 +183,7 @@ export function createRpcHandler(config, nc) {
                         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,
@@ -211,6 +212,8 @@ export function createRpcHandler(config, nc) {
                     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;
@@ -261,6 +264,7 @@ export function createRpcHandler(config, nc) {
                         triggers: [],
                         triggers_enabled: false,
                         requires_confirmation: params.requires_confirmation ?? false,
+                        ...(params.yolo_mode ? { yolo_mode: true } : {}),
                         ...(params.command ? { command: params.command } : {}),
                     },
                     body: "",
@@ -324,7 +328,7 @@ export function createRpcHandler(config, nc) {
                 await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
                 // 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);
+                const { command: cmd, args: cmdArgs, stdin } = followupAgent.getTaskRunCommandLine(followupTask, params.message, followupTask.frontmatter.yolo_mode ? "yolo" : followupTask.frontmatter.permissions);
                 // Spawn directly via crossSpawn so we can track and kill the child
                 const child = crossSpawn(cmd, cmdArgs, {
                     cwd: followupRunDir,
@@ -488,8 +492,8 @@ export function createRpcHandler(config, nc) {
                 const reports = [];
                 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/dist/task.d.ts

@@ -58,13 +58,23 @@ export declare function appendRunMessage(taskDir: string, runId: string, msg: Co
 export declare function beginStreamingMessage(taskDir: string, runId: string, time: number): StreamingMessageWriter;
 export declare class StreamingMessageWriter {
     private filePath;
-    private delimiter;
-    constructor(filePath: string, delimiter: string);
+    constructor(filePath: string);
     /** Append a chunk of content to the current message. */
     write(chunk: string): void;
-    /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+    /** Finalize the message. If attachments are provided, rewrites the last assistant delimiter to include them. */
     end(attachments?: string[]): void;
 }
+/**
+ * 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 declare function spliceUserMessage(taskDir: string, runId: string, userMsg: ConversationMessage, 
+/** Optional text to append to the current assistant block before ending it. */
+assistantAppend?: string): void;
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

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.
  */