palmier 0.4.3 → 0.4.5

package/README.md

@@ -127,11 +127,12 @@ palmier restart
 - **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional schedules (cron schedules or one-time dates).
 - **Plan generation** is automatic — when you create or update a task, the host invokes your chosen agent CLI to generate an execution plan and name.
 - **Schedules** are backed by systemd timers (Linux) or Task Scheduler (Windows). You can enable/disable them without deleting the task, and any task can still be run manually at any time.
-- **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
+- **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. On Windows, tasks run via a VBS wrapper (`wscript.exe`) to avoid visible console windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
 - **Command-triggered tasks** — optionally specify a shell command (e.g., `tail -f /var/log/app.log`). Palmier runs the command continuously and invokes the agent for each line of stdout, passing it alongside your prompt. Useful for log monitoring, event-driven automation, and reactive workflows.
 - **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (server mode) or a prompt in the PWA to confirm or abort.
-- **Run history** — each run produces a timestamped result file. You can view results and reports from the PWA.
-- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (LAN mode).
+- **Conversational run history** — each run gets its own directory (`tasks/<id>/<timestamp>/`) with a `TASKRUN.md` file containing a conversational thread: assistant messages (agent output), user messages (input responses, permission grants, confirmations), and status entries (started, finished, failed, aborted, stopped). The agent runs inside the run directory, so each run's session files and artifacts are isolated. The PWA displays runs as a chat-like thread with follow-up support.
+- **Follow-up messages** — after a task run completes, users can send follow-up messages from the run detail view. The agent is invoked inline by the serve daemon (no new process spawning), and the response is appended to the same conversation thread.
+- **Real-time updates** — task status changes and result updates are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (LAN mode). The run detail view live-updates as the agent produces output. Events are scoped to specific runs.
 - **Agent CLI commands** — `palmier notify` and `palmier request-input` allow agents to send push notifications and request user input during task execution without requiring MCP support.
 
 ## NATS Subjects
@@ -139,7 +140,7 @@ palmier restart
 | Subject | Direction | Description |
 |---|---|---|
 | `host.<hostId>.rpc.<method>` | Client → Host | RPC request/reply (e.g., `task.list`, `task.create`) |
-| `host-event.<hostId>.<taskId>` | Host → Client | Real-time task events (`running-state`, `confirm-request`, `permission-request`, `input-request`) |
+| `host-event.<hostId>.<taskId>` | Host → Client | Real-time task events (`running-state`, `result-updated`, `confirm-request`, `permission-request`, `input-request`) |
 | `host.<hostId>.push.send` | Host → Server | Request server to deliver a push notification |
 | `pair.<code>` | Client → Host | OTP pairing request/reply |
 
@@ -159,6 +160,8 @@ src/
   events.ts           # Event broadcasting (NATS pub/sub or HTTP SSE)
   agents/
     agent.ts          # AgentTool interface, registry, and agent detection
+    shared-prompt.ts  # Agent instructions loader
+    agent-instructions.md  # System prompt injected into every agent invocation
     claude.ts         # Claude Code agent implementation
     gemini.ts         # Gemini CLI agent implementation
     codex.ts          # Codex CLI agent implementation

package/dist/agents/agent.d.ts

@@ -12,10 +12,10 @@ export interface CommandLine {
 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 retryPrompt is provided, use it instead of the task's prompt,
+    /** 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, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
     /** 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>;

package/dist/agents/claude.d.ts

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

package/dist/agents/claude.js

@@ -8,16 +8,16 @@ export class ClaudeAgent {
             args: ["-p", prompt],
         };
     }
-    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
-        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (followupPrompt ?? (task.body || task.frontmatter.user_prompt));
         const args = ["--permission-mode", "acceptEdits", "-p"];
         const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
         for (const p of allPerms) {
             args.push("--allowedTools", p.name);
         }
-        if (retryPrompt) {
+        if (followupPrompt) {
             args.push("-c");
-        } // continue mode for retries
+        } // continue mode for followups
         return { command: "claude", args, stdin: prompt };
     }
     async init() {

package/dist/agents/codex.d.ts

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

package/dist/agents/codex.js

@@ -8,8 +8,8 @@ export class CodexAgent {
             args: ["exec", "--skip-git-repo-check", prompt],
         };
     }
-    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
-        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (followupPrompt ?? (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 ?? [])];
@@ -18,9 +18,9 @@ export class CodexAgent {
             args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
         }
         args.push("-"); // read prompt from stdin
-        if (retryPrompt) {
+        if (followupPrompt) {
             args.push("resume", "--last");
-        } // continue mode for retries
+        } // continue mode for followups
         return { command: "codex", args, stdin: prompt };
     }
     async init() {

package/dist/agents/copilot.d.ts

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

package/dist/agents/copilot.js

@@ -8,15 +8,15 @@ export class CopilotAgent {
             args: ["-p", prompt],
         };
     }
-    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
-        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (followupPrompt ?? (task.body || task.frontmatter.user_prompt));
         const args = ["-p", prompt];
         const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
         if (allPerms.length > 0) {
             args.push(`--allow-tool='${allPerms.map((p) => p.name).join(",")}'`);
             ;
         }
-        if (retryPrompt) {
+        if (followupPrompt) {
             args.push("--continue");
         }
         return { command: "copilot", args };

package/dist/agents/gemini.d.ts

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

package/dist/agents/gemini.js

@@ -8,8 +8,8 @@ export class GeminiAgent {
             args: ["--approval-mode", "auto_edit", "--prompt", prompt],
         };
     }
-    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
-        const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const prompt = followupPrompt ?? (task.body || task.frontmatter.user_prompt);
         const fullPrompt = AGENT_INSTRUCTIONS + "\n\n" + prompt;
         const args = ["--prompt", "-"];
         const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
@@ -19,9 +19,9 @@ export class GeminiAgent {
                 args.push(p.name);
             }
         }
-        if (retryPrompt) {
+        if (followupPrompt) {
             args.push("--resume");
-        } // continue mode for retries
+        } // continue mode for followups
         return { command: "gemini", args, stdin: fullPrompt };
     }
     async init() {

package/dist/agents/openclaw.d.ts

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

package/dist/agents/openclaw.js

@@ -7,8 +7,8 @@ export class OpenClawAgent {
             args: ["agent", "--local", "--agent", "main", "--message", prompt],
         };
     }
-    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
-        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const prompt = AGENT_INSTRUCTIONS + "\n\n" + (followupPrompt ?? (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/commands/request-input.d.ts

@@ -2,8 +2,7 @@
  * Request input from the user and print responses to stdout.
  * Usage: palmier request-input --description "Question 1" --description "Question 2"
  *
- * Requires PALMIER_TASK_ID environment variable to be set.
- * Outputs each response on its own line: "description: value"
+ * Requires PALMIER_TASK_ID and PALMIER_RUN_DIR environment variables.
  */
 export declare function requestInputCommand(opts: {
     description: string[];

package/dist/commands/request-input.js

@@ -1,13 +1,12 @@
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { getTaskDir, parseTaskFile, appendResultMessage } from "../task.js";
+import { getTaskDir, parseTaskFile, appendRunMessage } from "../task.js";
 import { requestUserInput, publishInputResolved } from "../user-input.js";
 /**
  * Request input from the user and print responses to stdout.
  * Usage: palmier request-input --description "Question 1" --description "Question 2"
  *
- * Requires PALMIER_TASK_ID environment variable to be set.
- * Outputs each response on its own line: "description: value"
+ * Requires PALMIER_TASK_ID and PALMIER_RUN_DIR environment variables.
  */
 export async function requestInputCommand(opts) {
     const taskId = process.env.PALMIER_TASK_ID;
@@ -19,33 +18,20 @@ export async function requestInputCommand(opts) {
     const nc = await connectNats(config);
     const taskDir = getTaskDir(config.projectRoot, taskId);
     const task = parseTaskFile(taskDir);
+    const runId = process.env.PALMIER_RUN_DIR?.split(/[/\\]/).pop();
     try {
         const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, opts.description);
         await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
         if (response === "aborted") {
-            // Write abort as user message if RESULT file is available
-            const resultFile = process.env.PALMIER_RESULT_FILE;
-            if (resultFile) {
-                appendResultMessage(taskDir, resultFile, {
-                    role: "user",
-                    time: Date.now(),
-                    content: "Input request aborted.",
-                    type: "input",
-                });
+            if (runId) {
+                appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Input request aborted.", type: "input" });
             }
             console.error("User aborted the input request.");
             process.exit(1);
         }
-        // Write user input as a conversation message
-        const resultFile = process.env.PALMIER_RESULT_FILE;
-        if (resultFile) {
+        if (runId) {
             const lines = opts.description.map((desc, i) => `**${desc}** ${response[i]}`);
-            appendResultMessage(taskDir, resultFile, {
-                role: "user",
-                time: Date.now(),
-                content: lines.join("\n"),
-                type: "input",
-            });
+            appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: lines.join("\n"), type: "input" });
         }
         for (let i = 0; i < opts.description.length; i++) {
             console.log(response[i]);

package/dist/commands/run.d.ts

@@ -1,4 +1,8 @@
 import type { TaskRunningState, RequiredPermission } from "../types.js";
+/**
+ * Strip [PALMIER_*] marker lines from agent output.
+ */
+export declare function stripPalmierMarkers(output: string): string;
 /**
  * Execute a task by ID.
  */

package/dist/commands/run.js

@@ -4,27 +4,27 @@ import * as readline from "readline";
 import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile, appendResultMessage, finalizeResultFrontmatter } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import { publishHostEvent } from "../events.js";
 import { waitForUserInput } from "../user-input.js";
 /**
- * Invoke the agent CLI with a retry loop for permissions and user input.
+ * Invoke the agent CLI with a continuation loop for permissions and user input.
  *
  * Both standard and command-triggered execution use this.
  * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
  * (for command-triggered mode this is the per-line augmented task).
  */
-async function invokeAgentWithRetry(ctx, invokeTask) {
-    let retryPrompt;
+async function invokeAgentWithContinuation(ctx, invokeTask) {
+    let followupPrompt;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
+        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, followupPrompt, ctx.transientPermissions);
         const result = await spawnCommand(command, args, {
-            cwd: ctx.taskDir,
-            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RESULT_FILE: ctx.resultFileName },
+            cwd: getRunDir(ctx.taskDir, ctx.runId),
+            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
             echoStdout: true,
             resolveOnFailure: true,
             stdin,
@@ -39,8 +39,8 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
             content: stripPalmierMarkers(result.output),
             attachments: reportFiles.length > 0 ? reportFiles : undefined,
         });
-        // Permission retry
-        if (outcome === "failed" && requiredPermissions.length > 0) {
+        // Permission handling — agent requested permissions
+        if (requiredPermissions.length > 0) {
             const response = await requestPermission(ctx.nc, ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
             await publishPermissionResolved(ctx.nc, ctx.config, ctx.taskId, response);
             if (response === "aborted") {
@@ -69,37 +69,42 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
             else {
                 ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
             }
-            retryPrompt = "Permissions granted, please continue.";
-            continue;
+            // If the agent actually failed, retry with the new permissions
+            if (outcome === "failed") {
+                followupPrompt = "Permissions granted, please continue.";
+                continue;
+            }
         }
-        // Normal completion (success or non-retryable failure)
+        // Normal completion (success or terminal failure)
         return { outcome };
     }
 }
 /**
  * Strip [PALMIER_*] marker lines from agent output.
  */
-function stripPalmierMarkers(output) {
+export function stripPalmierMarkers(output) {
     return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
 }
 /**
  * Append a conversation message to the RESULT file and notify connected clients.
  */
 async function appendAndNotify(ctx, msg) {
-    appendResultMessage(ctx.taskDir, ctx.resultFileName, msg);
-    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated" });
+    appendRunMessage(ctx.taskDir, ctx.runId, msg);
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
 /**
- * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ * Find the latest run dir that has no status messages yet (just created by the RPC handler).
  */
-function findStartedResultFile(taskDir) {
-    const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
-        if (content.includes("running_state: started"))
-            return file;
-    }
-    return null;
+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" to status.json (e.g. via task.abort),
@@ -121,30 +126,22 @@ export async function runCommand(taskId) {
     console.log(`Running task: ${taskId}`);
     let nc;
     const taskName = task.frontmatter.name;
-    // Check for an existing "started" result file (created by the RPC handler)
-    const existingResult = findStartedResultFile(taskDir);
-    const startTime = existingResult ? parseInt(existingResult.replace("RESULT-", "").replace(".md", ""), 10) : Date.now();
-    const resultFileName = existingResult ?? createResultFile(taskDir, taskName, startTime);
-    // Snapshot the task file at run time
-    const taskSnapshotName = `TASK-${startTime}.md`;
-    if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
-        fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    // Use existing run dir if just created by RPC, otherwise create a new one
+    const existingRunId = findLatestPendingRunId(taskDir);
+    const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now());
+    if (!existingRunId) {
+        appendHistory(config.projectRoot, { task_id: taskId, run_id: runId });
     }
     const cleanup = async () => {
         if (nc && !nc.isClosed()) {
             await nc.drain();
         }
     };
-    if (!existingResult) {
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    }
     try {
         nc = await connectNats(config);
-        // Mark as started immediately
-        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
-        // Status: started
-        appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "started" });
-        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, runId);
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "started" });
+        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(nc, config, task, taskDir);
@@ -152,30 +149,28 @@ export async function runCommand(taskId) {
             await publishConfirmResolved(nc, config, taskId, resolvedStatus);
             if (!confirmed) {
                 console.log("Task aborted by user.");
-                appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "aborted" });
-                finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: "aborted" });
-                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
+                appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
+                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, runId);
                 await cleanup();
                 return;
             }
             console.log("Task confirmed by user.");
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "confirmation" });
-            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "confirmation" });
+            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         }
         // Shared invocation context
         const guiEnv = getPlatform().getGuiEnv();
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
-            agent, task, taskDir, resultFileName, guiEnv, nc, config, taskId,
+            agent, task, taskDir, runId, guiEnv, nc, config, taskId,
             transientPermissions: [],
         };
         if (task.frontmatter.command) {
             // Command-triggered mode
             const result = await runCommandTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-            finalizeResultFrontmatter(taskDir, resultFileName, { end_time: result.endTime, running_state: outcome });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed (command-triggered).`);
         }
         else {
@@ -185,11 +180,10 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.body || task.frontmatter.user_prompt,
             });
-            const result = await invokeAgentWithRetry(ctx, task);
+            const result = await invokeAgentWithContinuation(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-            finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed.`);
         }
     }
@@ -197,14 +191,13 @@ export async function runCommand(taskId) {
         console.error(`Task ${taskId} failed:`, err);
         const outcome = resolveOutcome(taskDir, "failed");
         const errorMsg = err instanceof Error ? err.message : String(err);
-        appendResultMessage(taskDir, resultFileName, {
+        appendRunMessage(taskDir, runId, {
             role: "assistant",
             time: Date.now(),
             content: errorMsg,
         });
-        appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-        finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
         process.exitCode = 1;
     }
     finally {
@@ -226,8 +219,8 @@ async function runCommandTriggeredMode(ctx) {
     const commandStr = ctx.task.frontmatter.command;
     console.log(`[command-triggered] Spawning: ${commandStr}`);
     const child = spawnStreamingCommand(commandStr, {
-        cwd: ctx.taskDir,
-        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id },
+        cwd: getRunDir(ctx.taskDir, ctx.runId),
+        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
     });
     let linesProcessed = 0;
     let invocationsSucceeded = 0;
@@ -236,7 +229,7 @@ async function runCommandTriggeredMode(ctx) {
     let processing = false;
     let commandExited = false;
     let resolveWhenDone;
-    const logPath = path.join(ctx.taskDir, "command-output.log");
+    const logPath = path.join(getRunDir(ctx.taskDir, ctx.runId), "command-output.log");
     function appendLog(line, agentOutput, outcome) {
         const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
         fs.appendFileSync(logPath, entry, "utf-8");
@@ -265,7 +258,7 @@ async function runCommandTriggeredMode(ctx) {
             frontmatter: { ...ctx.task.frontmatter, user_prompt: perLinePrompt },
             body: "",
         };
-        const result = await invokeAgentWithRetry(ctx, perLineTask);
+        const result = await invokeAgentWithContinuation(ctx, perLineTask);
         if (result.outcome === "finished") {
             invocationsSucceeded++;
         }
@@ -330,7 +323,7 @@ async function runCommandTriggeredMode(ctx) {
     const endTime = Date.now();
     return { outcome: "finished", endTime };
 }
-async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, resultFile) {
+async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
@@ -339,8 +332,8 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
         payload.name = taskName;
-    if (resultFile)
-        payload.result_file = resultFile;
+    if (runId)
+        payload.run_id = runId;
     await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 /**

package/dist/commands/serve.js

@@ -4,7 +4,7 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { createRpcHandler } from "../rpc-handler.js";
 import { startNatsTransport } from "../transports/nats-transport.js";
-import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile, appendResultMessage } from "../task.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
 import { detectAgents } from "../agents/agent.js";
@@ -13,38 +13,11 @@ import { CONFIG_DIR } from "../config.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
- * Mark a stuck task as failed: update status.json, write RESULT, append history,
- * and broadcast the failure event.
- */
-async function markTaskFailed(config, nc, taskId, reason) {
-    const taskDir = getTaskDir(config.projectRoot, taskId);
-    const status = readTaskStatus(taskDir);
-    if (!status || status.running_state !== "started")
-        return;
-    console.log(`[monitor] Task ${taskId} ${reason}, marking as failed.`);
-    const endTime = Date.now();
-    writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-    let taskName = taskId;
-    try {
-        const task = parseTaskFile(taskDir);
-        taskName = task.frontmatter.name || taskId;
-    }
-    catch { /* use taskId as fallback */ }
-    const resultFileName = `RESULT-${endTime}.md`;
-    const content = `---\ntask_name: ${taskName}\nrunning_state: failed\nstart_time: ${status.time_stamp}\nend_time: ${endTime}\ntask_file: \n---\n\n`;
-    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-    appendResultMessage(taskDir, resultFileName, {
-        role: "assistant",
-        time: endTime,
-        content: reason,
-    });
-    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    const payload = { event_type: "running-state", running_state: "failed", name: taskName };
-    await publishHostEvent(nc, config.hostId, taskId, payload);
-}
-/**
- * Scan all tasks for any stuck in "start" state whose process is no longer alive.
+ * Scan all tasks for any stuck in "started" state whose process is no longer alive.
  * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ *
+ * Since run.ts creates the RESULT file and history entry at start, we just need to
+ * finalize the existing RESULT file, append a failed status entry, and broadcast.
  */
 async function checkStaleTasks(config, nc) {
     const tasksJsonl = path.join(config.projectRoot, "tasks.jsonl");
@@ -67,7 +40,32 @@ async function checkStaleTasks(config, nc) {
         // Ask the system scheduler if the task is still running
         if (platform.isTaskRunning(taskId))
             continue;
-        await markTaskFailed(config, nc, taskId, "Task process exited unexpectedly");
+        console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
+        const endTime = Date.now();
+        writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
+        // Find the latest run directory (created by run.ts at start)
+        const runId = fs.readdirSync(taskDir)
+            .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+            .sort()
+            .pop();
+        if (runId) {
+            appendRunMessage(taskDir, runId, {
+                role: "status",
+                time: endTime,
+                content: "",
+                type: "failed",
+            });
+        }
+        let taskName = taskId;
+        try {
+            taskName = parseTaskFile(taskDir).frontmatter.name || taskId;
+        }
+        catch { /* use taskId as fallback */ }
+        await publishHostEvent(nc, config.hostId, taskId, {
+            event_type: "running-state",
+            running_state: "failed",
+            name: taskName,
+        });
     }
 }
 /**