palmier 0.4.1 → 0.4.3

package/src/commands/request-input.ts

@@ -0,0 +1,65 @@
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile, appendResultMessage } 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"
+ */
+export async function requestInputCommand(opts: { description: string[] }): Promise<void> {
+  const taskId = process.env.PALMIER_TASK_ID;
+  if (!taskId) {
+    console.error("Error: PALMIER_TASK_ID environment variable is not set.");
+    process.exit(1);
+  }
+
+  const config = loadConfig();
+  const nc = await connectNats(config);
+  const taskDir = getTaskDir(config.projectRoot, taskId);
+  const task = parseTaskFile(taskDir);
+
+  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",
+        });
+      }
+      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) {
+      const lines = opts.description.map((desc, i) => `**${desc}** ${response[i]}`);
+      appendResultMessage(taskDir, resultFile, {
+        role: "user",
+        time: Date.now(),
+        content: lines.join("\n"),
+        type: "input",
+      });
+    }
+
+    for (let i = 0; i < opts.description.length; i++) {
+      console.log(response[i]);
+    }
+  } catch (err) {
+    console.error(`Error requesting user input: ${err}`);
+    process.exit(1);
+  } finally {
+    if (nc) await nc.drain();
+  }
+}

package/src/commands/run.ts

@@ -4,42 +4,16 @@ 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 } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile, appendResultMessage, finalizeResultFrontmatter } 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, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import type { AgentTool } from "../agents/agent.js";
 import { publishHostEvent } from "../events.js";
-import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
+import { waitForUserInput } from "../user-input.js";
 import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
 import type { NatsConnection } from "nats";
 
-/**
- * Write a time-stamped RESULT file with frontmatter.
- * Always generated, even for abort/fail.
- */
-
-/**
- * Update an existing result file with the final outcome.
- */
-function finalizeResultFile(
-  taskDir: string,
-  resultFileName: string,
-  taskName: string,
-  taskSnapshotName: string,
-  runningState: string,
-  startTime: number,
-  endTime: number,
-  output: string,
-  reportFiles: string[],
-  requiredPermissions: RequiredPermission[],
-): void {
-  const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
-  const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
-  const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
-  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-}
-
 /**
  * Shared context for agent invocation retry loops.
  * Passed around to avoid threading many individual parameters.
@@ -48,6 +22,7 @@ interface InvocationContext {
   agent: AgentTool;
   task: ParsedTask;
   taskDir: string;
+  resultFileName: string;
   guiEnv: Record<string, string>;
   nc: NatsConnection | undefined;
   config: HostConfig;
@@ -57,10 +32,7 @@ interface InvocationContext {
 }
 
 interface InvocationResult {
-  output: string;
   outcome: TaskRunningState;
-  reportFiles: string[];
-  requiredPermissions: RequiredPermission[];
 }
 
 /**
@@ -80,7 +52,7 @@ async function invokeAgentWithRetry(
     const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
     const result = await spawnCommand(command, args, {
       cwd: ctx.taskDir,
-      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id },
+      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RESULT_FILE: ctx.resultFileName },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -90,13 +62,27 @@ async function invokeAgentWithRetry(
     const reportFiles = parseReportFiles(result.output);
     const requiredPermissions = parsePermissions(result.output);
 
+    // Append assistant message for this invocation
+    await appendAndNotify(ctx, {
+      role: "assistant",
+      time: Date.now(),
+      content: stripPalmierMarkers(result.output),
+      attachments: reportFiles.length > 0 ? reportFiles : undefined,
+    });
+
     // Permission retry
     if (outcome === "failed" && 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") {
-        return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
+        await appendAndNotify(ctx, {
+          role: "user",
+          time: Date.now(),
+          content: "Permissions denied. Task aborted.",
+          type: "permission",
+        });
+        return { outcome: "failed" };
       }
 
       const newPerms = requiredPermissions.filter(
@@ -104,6 +90,14 @@ async function invokeAgentWithRetry(
           && !ctx.transientPermissions.some((ep) => ep.name === rp.name),
       );
 
+      // Append user message for permission grant
+      await appendAndNotify(ctx, {
+        role: "user",
+        time: Date.now(),
+        content: `Permissions granted: ${newPerms.map((p) => p.name).join(", ")}`,
+        type: "permission",
+      });
+
       if (response === "granted_all") {
         ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
         invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
@@ -116,26 +110,29 @@ async function invokeAgentWithRetry(
       continue;
     }
 
-    // Input retry
-    const inputRequests = parseInputRequests(result.output);
-    if (outcome === "failed" && inputRequests.length > 0) {
-      const response = await requestUserInput(ctx.nc, ctx.config, ctx.taskId, ctx.task.frontmatter.name, ctx.taskDir, inputRequests);
-      await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided");
-
-      if (response === "aborted") {
-        return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
-      }
-
-      const inputLines = inputRequests.map((desc, i) => `- ${desc} → ${response[i]}`).join("\n");
-      retryPrompt = `The user provided the following inputs:\n${inputLines}\nPlease continue with these values.`;
-      continue;
-    }
-
     // Normal completion (success or non-retryable failure)
-    return { output: result.output, outcome, reportFiles, requiredPermissions };
+    return { outcome };
   }
 }
 
+/**
+ * Strip [PALMIER_*] marker lines from agent output.
+ */
+function stripPalmierMarkers(output: string): string {
+  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: InvocationContext,
+  msg: Parameters<typeof appendResultMessage>[2],
+): Promise<void> {
+  appendResultMessage(ctx.taskDir, ctx.resultFileName, msg);
+  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated" });
+}
+
 /**
  * Find an existing RESULT file with running_state=started (created by the RPC handler).
  */
@@ -197,6 +194,10 @@ export async function runCommand(taskId: string): Promise<void> {
     // 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" });
+
     // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
       const confirmed = await requestConfirmation(nc, config, task, taskDir);
@@ -204,20 +205,22 @@ export async function runCommand(taskId: string): Promise<void> {
       await publishConfirmResolved(nc, config, taskId, resolvedStatus);
       if (!confirmed) {
         console.log("Task aborted by user.");
-        const endTime = Date.now();
-        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
+        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);
         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" });
     }
 
     // Shared invocation context
     const guiEnv = getPlatform().getGuiEnv();
     const agent = getAgent(task.frontmatter.agent);
     const ctx: InvocationContext = {
-      agent, task, taskDir, guiEnv, nc, config, taskId,
+      agent, task, taskDir, resultFileName, guiEnv, nc, config, taskId,
       transientPermissions: [],
     };
 
@@ -225,35 +228,36 @@ export async function runCommand(taskId: string): Promise<void> {
       // Command-triggered mode
       const result = await runCommandTriggeredMode(ctx);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+      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);
       console.log(`Task ${taskId} completed (command-triggered).`);
     } else {
-      // Standard execution
+      // Standard execution — add user prompt as first message
+      await appendAndNotify(ctx, {
+        role: "user",
+        time: Date.now(),
+        content: task.body || task.frontmatter.user_prompt,
+      });
+
       const result = await invokeAgentWithRetry(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
-
-      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
+      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);
-
-      if (result.reportFiles.length > 0) {
-        await publishHostEvent(nc, config.hostId, taskId, {
-          event_type: "report-generated",
-          name: taskName,
-          report_files: result.reportFiles,
-          running_state: outcome,
-          result_file: resultFileName,
-        });
-      }
-
       console.log(`Task ${taskId} completed.`);
     }
   } catch (err) {
     console.error(`Task ${taskId} failed:`, err);
-    const endTime = Date.now();
     const outcome = resolveOutcome(taskDir, "failed");
     const errorMsg = err instanceof Error ? err.message : String(err);
-    finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
+    appendResultMessage(taskDir, resultFileName, {
+      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);
     process.exitCode = 1;
   } finally {
@@ -275,7 +279,7 @@ const MAX_LINE_LENGTH = 200_000;
  */
 async function runCommandTriggeredMode(
   ctx: InvocationContext,
-): Promise<{ outcome: TaskRunningState; endTime: number; output: string }> {
+): Promise<{ outcome: TaskRunningState; endTime: number }> {
   const commandStr = ctx.task.frontmatter.command!;
   console.log(`[command-triggered] Spawning: ${commandStr}`);
 
@@ -331,7 +335,7 @@ async function runCommandTriggeredMode(
     } else {
       invocationsFailed++;
     }
-    appendLog(line, result.output, result.outcome);
+    appendLog(line, "", result.outcome);
   }
 
   async function drainQueue(): Promise<void> {
@@ -390,15 +394,7 @@ async function runCommandTriggeredMode(
   }
 
   const endTime = Date.now();
-  const summary = [
-    `Command: ${commandStr}`,
-    `Exit code: ${exitCode}`,
-    `Lines processed: ${linesProcessed}`,
-    `Agent invocations succeeded: ${invocationsSucceeded}`,
-    `Agent invocations failed: ${invocationsFailed}`,
-  ].join("\n");
-
-  return { outcome: "finished", endTime, output: summary };
+  return { outcome: "finished", endTime };
 }
 
 async function publishTaskEvent(
@@ -413,6 +409,7 @@ async function publishTaskEvent(
   writeTaskStatus(taskDir, {
     running_state: eventType,
     time_stamp: Date.now(),
+    ...(eventType === "started" ? { pid: process.pid } : {}),
   });
 
   const payload: Record<string, unknown> = { event_type: "running-state", running_state: eventType };
@@ -534,21 +531,6 @@ export function parsePermissions(output: string): RequiredPermission[] {
   return perms;
 }
 
-/**
- * Extract user input requests from agent output.
- * Looks for lines matching: [PALMIER_INPUT] <description>
- */
-export function parseInputRequests(output: string): string[] {
-  const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
-  const inputs: string[] = [];
-  let match;
-  while ((match = regex.exec(output)) !== null) {
-    const desc = match[1].trim();
-    if (desc) inputs.push(desc);
-  }
-  return inputs;
-}
-
 /**
  * Parse the agent's output for success/failure markers.
  * Falls back to "finished" if no marker is found.

package/src/commands/serve.ts

@@ -4,10 +4,9 @@ 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 } from "../task.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile, appendResultMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
-import { checkForUpdate } from "../update-checker.js";
 import { detectAgents } from "../agents/agent.js";
 import { saveConfig } from "../config.js";
 import type { HostConfig } from "../types.js";
@@ -42,8 +41,13 @@ async function markTaskFailed(
   } 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${reason}`;
+  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 };
@@ -109,10 +113,6 @@ export async function serveCommand(): Promise<void> {
     });
   }, POLL_INTERVAL_MS);
 
-  // Check for updates on startup and every 24 hours
-  checkForUpdate().catch(() => {});
-  setInterval(() => { checkForUpdate().catch(() => {}); }, 24 * 60 * 60 * 1000);
-
   const handleRpc = createRpcHandler(config, nc);
   await startNatsTransport(config, handleRpc, nc);
 }

package/src/index.ts

@@ -9,7 +9,8 @@ import { initCommand } from "./commands/init.js";
 import { infoCommand } from "./commands/info.js";
 import { runCommand } from "./commands/run.js";
 import { serveCommand } from "./commands/serve.js";
-import { mcpserverCommand } from "./commands/mcpserver.js";
+import { notifyCommand } from "./commands/notify.js";
+import { requestInputCommand } from "./commands/request-input.js";
 
 import { pairCommand } from "./commands/pair.js";
 import { lanCommand } from "./commands/lan.js";
@@ -62,10 +63,20 @@ program
   });
 
 program
-  .command("mcpserver")
-  .description("Start an MCP server exposing Palmier tools (stdio transport)")
-  .action(async () => {
-    await mcpserverCommand();
+  .command("notify")
+  .description("Send a push notification to the user")
+  .requiredOption("--title <title>", "Notification title")
+  .requiredOption("--body <body>", "Notification body text")
+  .action(async (opts: { title: string; body: string }) => {
+    await notifyCommand(opts);
+  });
+
+program
+  .command("request-input")
+  .description("Request input from the user (requires PALMIER_TASK_ID env var)")
+  .requiredOption("--description <desc...>", "Input descriptions to show the user")
+  .action(async (opts: { description: string[] }) => {
+    await requestInputCommand(opts);
   });
 
 program

package/src/platform/windows.ts

@@ -4,7 +4,8 @@ import { execFileSync } from "child_process";
 import { spawn as nodeSpawn } from "child_process";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
-import { CONFIG_DIR } from "../config.js";
+import { CONFIG_DIR, loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 
 
 const TASK_PREFIX = "\\Palmier\\PalmierTask-";
@@ -140,7 +141,7 @@ export class WindowsPlatform implements PlatformService {
     // Kill old daemon first, then spawn new one.
     if (oldPid) {
       try {
-        execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
+        execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
       } catch {
         // Process may have already exited
       }
@@ -225,6 +226,20 @@ export class WindowsPlatform implements PlatformService {
   }
 
   async stopTask(taskId: string): Promise<void> {
+    // Try to kill the entire process tree via the PID recorded in status.json.
+    // schtasks /end only kills the top-level process, leaving agent children orphaned.
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        execFileSync("taskkill", ["/pid", String(status.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+        return;
+      }
+    } catch {
+      // PID may be stale or config unavailable; fall through to schtasks /end
+    }
+
+    // Fallback: schtasks /end (kills top-level process only)
     const tn = schtasksTaskName(taskId);
     try {
       execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });

package/src/rpc-handler.ts

@@ -11,8 +11,8 @@ import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
 import { validateSession } from "./session-store.js";
 import { publishHostEvent } from "./events.js";
-import { currentVersion, getLatestVersion, performUpdate } from "./update-checker.js";
-import type { HostConfig, ParsedTask, RpcMessage } from "./types.js";
+import { currentVersion, performUpdate } from "./update-checker.js";
+import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -22,46 +22,72 @@ const PLAN_GENERATION_PROMPT = fs.readFileSync(
 );
 
 /**
- * Parse RESULT frontmatter into a metadata object.
+ * Parse RESULT frontmatter and conversation messages.
  */
 function parseResultFrontmatter(raw: string): Record<string, unknown> {
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!fmMatch) return { content: raw };
+  if (!fmMatch) return { messages: [] };
 
   const meta: Record<string, string> = {};
-  const requiredPermissions: Array<{ name: string; description: string }> = [];
   for (const line of fmMatch[1].split("\n")) {
     const sep = line.indexOf(": ");
     if (sep === -1) continue;
-    const key = line.slice(0, sep).trim();
-    const value = line.slice(sep + 2).trim();
-    if (key === "required_permission") {
-      const pipeSep = value.indexOf("|");
-      if (pipeSep !== -1) {
-        requiredPermissions.push({ name: value.slice(0, pipeSep).trim(), description: value.slice(pipeSep + 1).trim() });
-      } else {
-        requiredPermissions.push({ name: value, description: "" });
-      }
-    } else {
-      meta[key] = value;
-    }
+    meta[line.slice(0, sep).trim()] = line.slice(sep + 2).trim();
   }
-  const reportFiles = meta.report_files
-    ? meta.report_files.split(",").map((f: string) => f.trim()).filter(Boolean)
-    : [];
+
+  const messages = parseConversationMessages(fmMatch[2]);
 
   return {
-    content: fmMatch[2],
+    messages,
     task_name: meta.task_name,
     running_state: meta.running_state,
     start_time: meta.start_time ? Number(meta.start_time) : undefined,
     end_time: meta.end_time ? Number(meta.end_time) : undefined,
     task_file: meta.task_file,
-    report_files: reportFiles.length > 0 ? reportFiles : undefined,
-    required_permissions: requiredPermissions.length > 0 ? requiredPermissions : undefined,
   };
 }
 
+/**
+ * Parse conversation messages from the body of a RESULT file.
+ */
+function parseConversationMessages(body: string): ConversationMessage[] {
+  const delimiterRegex = /<!-- palmier:message\s+(.*?)\s*-->/g;
+  const messages: ConversationMessage[] = [];
+  const matches = [...body.matchAll(delimiterRegex)];
+
+  if (matches.length === 0) {
+    // No delimiters — treat entire body as single assistant message if non-empty
+    const content = body.trim();
+    if (content) {
+      messages.push({ role: "assistant", time: 0, content });
+    }
+    return messages;
+  }
+
+  for (let i = 0; i < matches.length; i++) {
+    const match = matches[i];
+    const attrs = match[1];
+    const start = match.index! + match[0].length;
+    const end = i + 1 < matches.length ? matches[i + 1].index! : body.length;
+    const content = body.slice(start, end).trim();
+
+    const role = (parseAttr(attrs, "role") ?? "assistant") as "assistant" | "user";
+    const time = Number(parseAttr(attrs, "time") ?? "0");
+    const type = parseAttr(attrs, "type") as ConversationMessage["type"];
+    const attachmentsRaw = parseAttr(attrs, "attachments");
+    const attachments = attachmentsRaw ? attachmentsRaw.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+
+    messages.push({ role, time, content, ...(type ? { type } : {}), ...(attachments ? { attachments } : {}) });
+  }
+
+  return messages;
+}
+
+function parseAttr(attrs: string, name: string): string | undefined {
+  const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+  return match ? match[1] : undefined;
+}
+
 /**
  * Run plan generation for a task prompt using the given agent.
  * Returns the generated plan body and task name.
@@ -124,7 +150,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
           version: currentVersion,
-          latest_version: getLatestVersion(),
         };
       }
 
@@ -409,8 +434,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           try {
             const raw = fs.readFileSync(resultPath, "utf-8");
             const meta = parseResultFrontmatter(raw);
-            // Exclude full content from list response
-            const { content: _, ...rest } = meta;
+            // Exclude messages from list response
+            const { messages: _, ...rest } = meta;
             return { ...entry, ...rest };
           } catch {
             return { ...entry, error: "Result file not found" };

package/src/spawn-command.ts

@@ -1,5 +1,16 @@
 import crossSpawn from "cross-spawn";
-import type { ChildProcess } from "child_process";
+import { execFileSync, type ChildProcess } from "child_process";
+
+/** Kill a child process and its entire tree on Windows; plain kill elsewhere. */
+function treeKill(child: ChildProcess): void {
+  if (process.platform === "win32" && child.pid) {
+    try {
+      execFileSync("taskkill", ["/pid", String(child.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+      return;
+    } catch { /* fall through */ }
+  }
+  child.kill();
+}
 
 export interface SpawnStreamingOptions {
   cwd: string;
@@ -100,7 +111,7 @@ export function spawnCommand(
     let timer: ReturnType<typeof setTimeout> | undefined;
     if (opts.timeout) {
       timer = setTimeout(() => {
-        child.kill();
+        treeKill(child);
         reject(new Error("command timed out"));
       }, opts.timeout);
     }