palmier 0.4.3 → 0.4.5

package/dist/types.d.ts

@@ -61,7 +61,7 @@ export interface TaskStatus {
 }
 export interface HistoryEntry {
     task_id: string;
-    result_file: string;
+    run_id: string;
 }
 export interface RequiredPermission {
     name: string;
@@ -71,7 +71,7 @@ export interface ConversationMessage {
     role: "assistant" | "user" | "status";
     time: number;
     content: string;
-    type?: "input" | "permission" | "confirmation" | "started" | "finished" | "failed" | "aborted";
+    type?: "input" | "permission" | "confirmation" | "started" | "finished" | "failed" | "aborted" | "stopped";
     attachments?: string[];
 }
 export interface RpcMessage {

package/package.json

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

package/src/agents/agent.ts

@@ -20,10 +20,10 @@ 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. */

package/src/agents/claude.ts

@@ -12,8 +12,8 @@ export class ClaudeAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    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 ?? [])];
@@ -21,7 +21,7 @@ export class ClaudeAgent implements AgentTool {
       args.push("--allowedTools", p.name);
     }
 
-    if (retryPrompt) {args.push("-c");} // continue mode for retries
+    if (followupPrompt) {args.push("-c");} // continue mode for followups
     return { command: "claude", args, stdin: prompt };
   }
 

package/src/agents/codex.ts

@@ -12,8 +12,8 @@ export class CodexAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    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"];
 
@@ -24,7 +24,7 @@ export class CodexAgent implements AgentTool {
     }
     args.push("-"); // read prompt from stdin
 
-    if (retryPrompt) {args.push("resume", "--last");} // continue mode for retries
+    if (followupPrompt) {args.push("resume", "--last");} // continue mode for followups
     return { command: "codex", args, stdin: prompt };
   }
 

package/src/agents/copilot.ts

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

package/src/agents/gemini.ts

@@ -12,8 +12,8 @@ export class GeminiAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = followupPrompt ?? (task.body || task.frontmatter.user_prompt);
     const fullPrompt = AGENT_INSTRUCTIONS + "\n\n" + prompt;
     const args = ["--prompt", "-"];
 
@@ -25,7 +25,7 @@ export class GeminiAgent implements AgentTool {
       }
     }
 
-    if (retryPrompt) {args.push("--resume");} // continue mode for retries
+    if (followupPrompt) {args.push("--resume");} // continue mode for followups
     return { command: "gemini", args, stdin: fullPrompt };
   }
 

package/src/agents/openclaw.ts

@@ -11,8 +11,8 @@ export class OpenClawAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    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];
 

package/src/commands/request-input.ts

@@ -1,14 +1,13 @@
 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: { description: string[] }): Promise<void> {
   const taskId = process.env.PALMIER_TASK_ID;
@@ -21,36 +20,23 @@ export async function requestInputCommand(opts: { description: string[] }): Prom
   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++) {

package/src/commands/run.ts

@@ -4,7 +4,7 @@ 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";
@@ -22,7 +22,7 @@ interface InvocationContext {
   agent: AgentTool;
   task: ParsedTask;
   taskDir: string;
-  resultFileName: string;
+  runId: string;
   guiEnv: Record<string, string>;
   nc: NatsConnection | undefined;
   config: HostConfig;
@@ -36,23 +36,23 @@ interface InvocationResult {
 }
 
 /**
- * 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(
+async function invokeAgentWithContinuation(
   ctx: InvocationContext,
   invokeTask: ParsedTask,
 ): Promise<InvocationResult> {
-  let retryPrompt: string | undefined;
+  let followupPrompt: string | undefined;
   // 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,
@@ -70,8 +70,8 @@ async function invokeAgentWithRetry(
       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);
 
@@ -106,11 +106,14 @@ async function invokeAgentWithRetry(
         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 };
   }
 }
@@ -118,7 +121,7 @@ async function invokeAgentWithRetry(
 /**
  * Strip [PALMIER_*] marker lines from agent output.
  */
-function stripPalmierMarkers(output: string): string {
+export function stripPalmierMarkers(output: string): string {
   return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
 }
 
@@ -127,22 +130,24 @@ function stripPalmierMarkers(output: string): string {
  */
 async function appendAndNotify(
   ctx: InvocationContext,
-  msg: Parameters<typeof appendResultMessage>[2],
+  msg: Parameters<typeof appendRunMessage>[2],
 ): Promise<void> {
-  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: string): string | null {
-  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: string): string | null {
+  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;
 }
 
 /**
@@ -167,15 +172,11 @@ export async function runCommand(taskId: string): Promise<void> {
   let nc: NatsConnection | undefined;
   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 () => {
@@ -184,19 +185,12 @@ export async function runCommand(taskId: string): Promise<void> {
     }
   };
 
-  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) {
@@ -205,22 +199,21 @@ export async function runCommand(taskId: string): Promise<void> {
       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: InvocationContext = {
-      agent, task, taskDir, resultFileName, guiEnv, nc, config, taskId,
+      agent, task, taskDir, runId, guiEnv, nc, config, taskId,
       transientPermissions: [],
     };
 
@@ -228,9 +221,8 @@ export async function runCommand(taskId: string): Promise<void> {
       // 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 {
       // Standard execution — add user prompt as first message
@@ -240,25 +232,23 @@ export async function runCommand(taskId: string): Promise<void> {
         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.`);
     }
   } catch (err) {
     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 {
     await cleanup();
@@ -284,8 +274,8 @@ async function runCommandTriggeredMode(
   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;
@@ -297,7 +287,7 @@ async function runCommandTriggeredMode(
   let commandExited = false;
   let resolveWhenDone: (() => void) | undefined;
 
-  const logPath = path.join(ctx.taskDir, "command-output.log");
+  const logPath = path.join(getRunDir(ctx.taskDir, ctx.runId), "command-output.log");
   function appendLog(line: string, agentOutput: string, outcome: string) {
     const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
     fs.appendFileSync(logPath, entry, "utf-8");
@@ -329,7 +319,7 @@ async function runCommandTriggeredMode(
       body: "",
     };
 
-    const result = await invokeAgentWithRetry(ctx, perLineTask);
+    const result = await invokeAgentWithContinuation(ctx, perLineTask);
     if (result.outcome === "finished") {
       invocationsSucceeded++;
     } else {
@@ -404,7 +394,7 @@ async function publishTaskEvent(
   taskId: string,
   eventType: TaskRunningState,
   taskName?: string,
-  resultFile?: string,
+  runId?: string,
 ): Promise<void> {
   writeTaskStatus(taskDir, {
     running_state: eventType,
@@ -414,7 +404,7 @@ async function publishTaskEvent(
 
   const payload: Record<string, unknown> = { 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/src/commands/serve.ts

@@ -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";
@@ -17,46 +17,11 @@ 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: HostConfig,
-  nc: NatsConnection | undefined,
-  taskId: string,
-  reason: string,
-): Promise<void> {
-  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: Record<string, unknown> = { 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: HostConfig,
@@ -80,7 +45,35 @@ async function checkStaleTasks(
     // 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,
+    });
   }
 }
 

package/src/platform/linux.ts

@@ -5,6 +5,8 @@ import { execSync, exec } from "child_process";
 import { promisify } from "util";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
+import { loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 
 const execAsync = promisify(exec);
 
@@ -230,20 +232,28 @@ WantedBy=timers.target
   }
 
   isTaskRunning(taskId: string): boolean {
+    // Check systemd first (for scheduled/on-demand runs)
     const serviceName = getServiceName(taskId);
     try {
-      // is-active exits 0 only for "active". For oneshot services (Type=oneshot),
-      // the state is "activating" while running, which exits non-zero.
-      // Use show -p ActiveState to reliably get the state without exit code issues.
       const out = execSync(
         `systemctl --user show -p ActiveState --value ${serviceName}`,
         { encoding: "utf-8" },
       );
       const state = out.trim();
-      return state === "active" || state === "activating";
-    } catch {
-      return false;
-    }
+      if (state === "active" || state === "activating") return true;
+    } catch { /* service may not exist */ }
+
+    // Fall back to PID check (for follow-up runs spawned directly)
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        process.kill(status.pid, 0); // signal 0 = check if process exists
+        return true;
+      }
+    } catch { /* process not running or config unavailable */ }
+
+    return false;
   }
 
   getGuiEnv(): Record<string, string> {