palmier 0.4.2 → 0.4.4

package/src/rpc-handler.ts

@@ -2,17 +2,19 @@ import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { spawn } from "child_process";
+import { spawn, type ChildProcess } from "child_process";
 import { parse as parseYaml } from "yaml";
 import { type NatsConnection } from "nats";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createResultFile } from "./task.js";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createRunDir, appendRunMessage, getRunDir } from "./task.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
+import crossSpawn from "cross-spawn";
 import { getAgent } from "./agents/agent.js";
 import { validateSession } from "./session-store.js";
 import { publishHostEvent } from "./events.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
-import type { HostConfig, ParsedTask, RpcMessage } from "./types.js";
+import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
+import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -22,46 +24,86 @@ 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 messages = parseConversationMessages(fmMatch[2]);
+
+  // Derive state from status messages — just look at the last one
+  const statusMessages = messages.filter((m: ConversationMessage) => m.role === "status");
+  const lastStatus = statusMessages[statusMessages.length - 1];
+  const startedMsg = statusMessages.find((m: ConversationMessage) => m.type === "started");
+  const terminalStates = ["finished", "failed", "aborted"];
+  const terminalMsg = [...statusMessages].reverse().find((m: ConversationMessage) => terminalStates.includes(m.type ?? ""));
+
+  // If last status is "started", determine if it's a task run or follow-up
+  let runningState: string | undefined;
+  if (lastStatus?.type === "started") {
+    runningState = terminalMsg ? "followup" : "started";
+  } else {
+    runningState = lastStatus?.type;
   }
-  const reportFiles = meta.report_files
-    ? meta.report_files.split(",").map((f: string) => f.trim()).filter(Boolean)
-    : [];
 
   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,
+    running_state: runningState,
+    start_time: startedMsg?.time || undefined,
+    end_time: terminalMsg?.time || 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.
@@ -98,6 +140,9 @@ async function generatePlan(
   return { name, body };
 }
 
+/** Active follow-up child processes, keyed by "taskId:runId". */
+const activeFollowups = new Map<string, ChildProcess>();
+
 /**
  * Create a transport-agnostic RPC handler bound to the given config.
  */
@@ -272,8 +317,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // Do NOT append to tasks.jsonl — this is a one-off run
 
         // Create initial result file so it appears in runs list immediately
-        const resultFileName = createResultFile(taskDir, name, Date.now());
-        appendHistory(config.projectRoot, { task_id: id, result_file: resultFileName });
+        const runId = createRunDir(taskDir, name, Date.now());
+        appendHistory(config.projectRoot, { task_id: id, run_id: runId });
 
         // Spawn `palmier run <id>` directly as a detached process
         const script = process.argv[1] || "palmier";
@@ -284,7 +329,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         });
         child.unref();
 
-        return { ok: true, task_id: id, result_file: resultFileName };
+        return { ok: true, task_id: id, run_id: runId };
       }
 
       case "task.run": {
@@ -293,11 +338,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           // Create initial result file so it appears in runs list immediately
           const runTaskDir = getTaskDir(config.projectRoot, params.id);
           const runTask = parseTaskFile(runTaskDir);
-          const runResultFileName = createResultFile(runTaskDir, runTask.frontmatter.name, Date.now());
-          appendHistory(config.projectRoot, { task_id: params.id, result_file: runResultFileName });
+          const taskRunId = createRunDir(runTaskDir, runTask.frontmatter.name, Date.now());
+          appendHistory(config.projectRoot, { task_id: params.id, run_id: taskRunId });
 
           await getPlatform().startTask(params.id);
-          return { ok: true, task_id: params.id, result_file: runResultFileName };
+          return { ok: true, task_id: params.id, run_id: taskRunId };
         } catch (err: unknown) {
           const e = err as { stderr?: string; message?: string };
           console.error(`task.run failed for ${params.id}: ${e.stderr || e.message}`);
@@ -305,15 +350,157 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         }
       }
 
+      case "task.followup": {
+        const params = request.params as { id: string; run_id: string; message: string };
+        if (!params.run_id || !params.message?.trim()) {
+          return { error: "run_id and message are required" };
+        }
+        const followupKey = `${params.id}:${params.run_id}`;
+        if (activeFollowups.has(followupKey)) {
+          return { error: "A follow-up is already running for this run" };
+        }
+
+        const followupTaskDir = getTaskDir(config.projectRoot, params.id);
+        const followupTask = parseTaskFile(followupTaskDir);
+        const followupRunDir = getRunDir(followupTaskDir, params.run_id);
+
+        // Append user message + started status
+        appendRunMessage(followupTaskDir, params.run_id, {
+          role: "user",
+          time: Date.now(),
+          content: params.message,
+        });
+        appendRunMessage(followupTaskDir, params.run_id, {
+          role: "status",
+          time: Date.now(),
+          content: "",
+          type: "started",
+        });
+        await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
+
+        // Fire-and-forget: invoke agent inline as a child of the serve process
+        const followupAgent = getAgent(followupTask.frontmatter.agent);
+        const { command: cmd, args: cmdArgs, stdin } = followupAgent.getTaskRunCommandLine(
+          followupTask, params.message, followupTask.frontmatter.permissions,
+        );
+
+        // Spawn directly via crossSpawn so we can track and kill the child
+        const child = crossSpawn(cmd, cmdArgs, {
+          cwd: followupRunDir,
+          stdio: [stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
+          env: { ...process.env, PALMIER_TASK_ID: params.id },
+          windowsHide: true,
+        });
+        if (stdin != null) child.stdin!.end(stdin);
+        activeFollowups.set(followupKey, child);
+
+        // Collect output
+        const chunks: Buffer[] = [];
+        child.stdout?.on("data", (d: Buffer) => chunks.push(d));
+        child.stderr?.on("data", (d: Buffer) => process.stderr.write(d));
+
+        child.on("close", async (code: number | null) => {
+          activeFollowups.delete(followupKey);
+          // If killed by stop_followup, the stopped status is already written
+          if (child.killed) return;
+
+          const output = Buffer.concat(chunks).toString("utf-8");
+          const outcome = code !== 0 ? "failed" : parseTaskOutcome(output);
+          const reportFiles = parseReportFiles(output);
+
+          appendRunMessage(followupTaskDir, params.run_id, {
+            role: "assistant",
+            time: Date.now(),
+            content: stripPalmierMarkers(output),
+            attachments: reportFiles.length > 0 ? reportFiles : undefined,
+          });
+          appendRunMessage(followupTaskDir, params.run_id, {
+            role: "status",
+            time: Date.now(),
+            content: "",
+            type: outcome,
+          });
+          await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
+        });
+
+        child.on("error", async (err: Error) => {
+          activeFollowups.delete(followupKey);
+          console.error(`Follow-up failed for ${followupKey}:`, err);
+          appendRunMessage(followupTaskDir, params.run_id, {
+            role: "status",
+            time: Date.now(),
+            content: "",
+            type: "failed",
+          });
+          await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
+        });
+
+        return { ok: true, task_id: params.id, run_id: params.run_id };
+      }
+
+      case "task.stop_followup": {
+        const params = request.params as { id: string; run_id: string };
+        if (!params.run_id) {
+          return { error: "run_id is required" };
+        }
+        const stopKey = `${params.id}:${params.run_id}`;
+        const child = activeFollowups.get(stopKey);
+        if (!child) {
+          return { error: "No active follow-up for this run" };
+        }
+
+        // Kill the child process tree
+        if (process.platform === "win32" && child.pid) {
+          try {
+            const { execFileSync } = await import("child_process");
+            execFileSync("taskkill", ["/pid", String(child.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+          } catch { /* may have already exited */ }
+        } else {
+          child.kill();
+        }
+
+        // Append stopped status (child.killed prevents the close handler from writing)
+        const stopTaskDir = getTaskDir(config.projectRoot, params.id);
+        appendRunMessage(stopTaskDir, params.run_id, {
+          role: "status",
+          time: Date.now(),
+          content: "",
+          type: "stopped",
+        });
+        activeFollowups.delete(stopKey);
+        await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
+        return { ok: true, task_id: params.id, run_id: params.run_id };
+      }
+
       case "task.abort": {
         const params = request.params as { id: string };
+        const abortTaskDir = getTaskDir(config.projectRoot, params.id);
+        // Read the PID before overwriting status — stopTask needs it to
+        // kill the entire process tree on Windows.
+        const abortPrevStatus = readTaskStatus(abortTaskDir);
         // Write abort status BEFORE killing so the dying process's signal
         // handler can detect this was RPC-initiated and skip publishing.
-        const abortTaskDir = getTaskDir(config.projectRoot, params.id);
         writeTaskStatus(abortTaskDir, {
           running_state: "aborted",
           time_stamp: Date.now(),
+          ...(abortPrevStatus?.pid ? { pid: abortPrevStatus.pid } : {}),
         });
+        // Append aborted status to the latest run
+        try {
+          const runDirs = fs.readdirSync(abortTaskDir)
+            .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(abortTaskDir, f, "TASKRUN.md")))
+            .sort();
+          const latestRunId = runDirs[runDirs.length - 1];
+          if (latestRunId) {
+            appendRunMessage(abortTaskDir, latestRunId, {
+              role: "status",
+              time: Date.now(),
+              content: "",
+              type: "aborted",
+            });
+          }
+        } catch { /* best-effort */ }
+
         try {
           await getPlatform().stopTask(params.id);
         } catch (err: unknown) {
@@ -338,27 +525,28 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
       }
 
       case "task.result": {
-        const params = request.params as { id: string; result_file: string };
-        if (!params.result_file) {
-          return { error: "result_file is required" };
+        const params = request.params as { id: string; run_id: string };
+        if (!params.run_id) {
+          return { error: "run_id is required" };
         }
-        const resultPath = path.join(config.projectRoot, "tasks", params.id, params.result_file);
+        const taskrunPath = path.join(config.projectRoot, "tasks", params.id, params.run_id, "TASKRUN.md");
 
         try {
-          const raw = fs.readFileSync(resultPath, "utf-8");
+          const raw = fs.readFileSync(taskrunPath, "utf-8");
           const meta = parseResultFrontmatter(raw);
           return { task_id: params.id, ...meta };
         } catch {
-          return { task_id: params.id, error: "No result file found" };
+          return { task_id: params.id, error: "Run not found" };
         }
       }
 
       case "task.reports": {
-        const params = request.params as { id: string; report_files: string[] };
-        if (!Array.isArray(params.report_files) || params.report_files.length === 0) {
-          return { error: "report_files must be a non-empty array" };
+        const params = request.params as { id: string; run_id: string; report_files: string[] };
+        if (!params.run_id || !Array.isArray(params.report_files) || params.report_files.length === 0) {
+          return { error: "run_id and report_files are required" };
         }
         const reports: Array<{ file: string; content?: string; error?: string }> = [];
+        const runDir = path.join(config.projectRoot, "tasks", params.id, params.run_id);
         for (const file of params.report_files) {
           if (!file.endsWith(".md")) {
             reports.push({ file, error: "must end with .md" });
@@ -369,7 +557,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             reports.push({ file, error: "must be a plain filename" });
             continue;
           }
-          const reportPath = path.join(config.projectRoot, "tasks", params.id, basename);
+          const reportPath = path.join(runDir, basename);
           try {
             const content = fs.readFileSync(reportPath, "utf-8");
             reports.push({ file, content });
@@ -395,7 +583,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true };
       }
 
-      case "activity.list": {
+      case "taskrun.list": {
         const params = request.params as { offset?: number; limit?: number; task_id?: string };
         const { entries, total } = readHistory(config.projectRoot, {
           offset: params.offset ?? 0,
@@ -404,31 +592,30 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         });
 
         const enriched = entries.map((entry) => {
-          const resultPath = path.join(config.projectRoot, "tasks", entry.task_id, entry.result_file);
+          const taskrunPath = path.join(config.projectRoot, "tasks", entry.task_id, entry.run_id, "TASKRUN.md");
           try {
-            const raw = fs.readFileSync(resultPath, "utf-8");
+            const raw = fs.readFileSync(taskrunPath, "utf-8");
             const meta = parseResultFrontmatter(raw);
-            // Exclude full content from list response
-            const { content: _, ...rest } = meta;
+            const { messages: _, ...rest } = meta;
             return { ...entry, ...rest };
           } catch {
-            return { ...entry, error: "Result file not found" };
+            return { ...entry, error: "Run not found" };
           }
         });
 
         return { entries: enriched, total };
       }
 
-      case "activity.delete": {
-        const params = request.params as { task_id: string; result_file: string };
-        if (!params.task_id || !params.result_file) {
-          return { error: "task_id and result_file are required" };
+      case "taskrun.delete": {
+        const params = request.params as { task_id: string; run_id: string };
+        if (!params.task_id || !params.run_id) {
+          return { error: "task_id and run_id are required" };
         }
-        const deleted = deleteHistoryEntry(config.projectRoot, params.task_id, params.result_file);
+        const deleted = deleteHistoryEntry(config.projectRoot, params.task_id, params.run_id);
         if (!deleted) {
           return { error: "History entry not found" };
         }
-        return { ok: true, task_id: params.task_id, result_file: params.result_file };
+        return { ok: true, task_id: params.task_id, run_id: params.run_id };
       }
 
       case "host.update": {

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);
     }

package/src/task.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import type { ParsedTask, TaskFrontmatter, TaskStatus, HistoryEntry } from "./types.js";
+import type { ParsedTask, TaskFrontmatter, TaskStatus, HistoryEntry, ConversationMessage } from "./types.js";
 
 /**
  * Parse a TASK.md file from the given task directory.
@@ -148,20 +148,81 @@ export function readTaskStatus(taskDir: string): TaskStatus | undefined {
 }
 
 /**
- * Create the initial result file when a task starts running.
- * Contains only start_time and running_state=started; no end_time or content yet.
- * Returns the result file name.
+ * Create a run directory with an initial TASKRUN.md file.
+ * Returns the run ID (timestamp string used as directory name).
  */
-export function createResultFile(
+export function createRunDir(
   taskDir: string,
   taskName: string,
   startTime: number,
 ): string {
-  const resultFileName = `RESULT-${startTime}.md`;
-  const taskSnapshotName = `TASK-${startTime}.md`;
-  const content = `---\ntask_name: ${taskName}\nrunning_state: started\nstart_time: ${startTime}\ntask_file: ${taskSnapshotName}\n---\n`;
-  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-  return resultFileName;
+  const runId = String(startTime);
+  const runDir = path.join(taskDir, runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  const content = `---\ntask_name: ${taskName}\n---\n\n`;
+  fs.writeFileSync(path.join(runDir, "TASKRUN.md"), content, "utf-8");
+  return runId;
+}
+
+/**
+ * Get the path to a run directory.
+ */
+export function getRunDir(taskDir: string, runId: string): string {
+  return path.join(taskDir, runId);
+}
+
+/**
+ * Append a conversation message to a run's TASKRUN.md file.
+ */
+export function appendRunMessage(
+  taskDir: string,
+  runId: string,
+  msg: ConversationMessage,
+): void {
+  const attrs = [`role="${msg.role}"`, `time="${msg.time}"`];
+  if (msg.type) attrs.push(`type="${msg.type}"`);
+  if (msg.attachments?.length) attrs.push(`attachments="${msg.attachments.join(",")}"`);
+
+  const delimiter = `<!-- palmier:message ${attrs.join(" ")} -->`;
+  const entry = `${delimiter}\n\n${msg.content}\n\n`;
+  fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
+}
+
+/**
+ * Read conversation messages from a run's TASKRUN.md file.
+ */
+export function readRunMessages(taskDir: string, runId: string): ConversationMessage[] {
+  const raw = fs.readFileSync(path.join(taskDir, runId, "TASKRUN.md"), "utf-8");
+  const fmMatch = raw.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+  if (!fmMatch) return [];
+
+  const body = fmMatch[1];
+  const delimiterRegex = /<!-- palmier:message\s+(.*?)\s*-->/g;
+  const matches = [...body.matchAll(delimiterRegex)];
+  if (matches.length === 0) return [];
+
+  const messages: ConversationMessage[] = [];
+  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 roleAttr = attrs.match(/role="([^"]*)"/)?.[1] ?? "assistant";
+    const timeAttr = attrs.match(/time="([^"]*)"/)?.[1] ?? "0";
+    const typeAttr = attrs.match(/type="([^"]*)"/)?.[1];
+    const attachmentsAttr = attrs.match(/attachments="([^"]*)"/)?.[1];
+
+    messages.push({
+      role: roleAttr as ConversationMessage["role"],
+      time: Number(timeAttr),
+      content,
+      ...(typeAttr ? { type: typeAttr as ConversationMessage["type"] } : {}),
+      ...(attachmentsAttr ? { attachments: attachmentsAttr.split(",").map((f) => f.trim()).filter(Boolean) } : {}),
+    });
+  }
+  return messages;
 }
 
 /**
@@ -173,13 +234,13 @@ export function appendHistory(projectRoot: string, entry: HistoryEntry): void {
 }
 
 /**
- * Delete a history entry and its associated result/task-snapshot files.
+ * Delete a history entry and its associated run directory.
  * Returns true if the entry was found and removed.
  */
 export function deleteHistoryEntry(
   projectRoot: string,
   taskId: string,
-  resultFile: string,
+  runId: string,
 ): boolean {
   const historyPath = path.join(projectRoot, "history.jsonl");
   if (!fs.existsSync(historyPath)) return false;
@@ -191,9 +252,9 @@ export function deleteHistoryEntry(
   for (const line of lines) {
     try {
       const entry = JSON.parse(line) as HistoryEntry;
-      if (entry.task_id === taskId && entry.result_file === resultFile) {
+      if (entry.task_id === taskId && entry.run_id === runId) {
         found = true;
-        continue; // skip this entry
+        continue;
       }
     } catch { /* keep malformed lines */ }
     remaining.push(line);
@@ -201,23 +262,12 @@ export function deleteHistoryEntry(
 
   if (!found) return false;
 
-  // Rewrite history.jsonl without the deleted entry
   fs.writeFileSync(historyPath, remaining.length > 0 ? remaining.join("\n") + "\n" : "", "utf-8");
 
-  // Delete the result file
-  const resultPath = path.join(projectRoot, "tasks", taskId, resultFile);
-  if (fs.existsSync(resultPath)) {
-    fs.unlinkSync(resultPath);
-  }
-
-  // Delete the corresponding task snapshot (TASK-<timestamp>.md)
-  const tsMatch = resultFile.match(/^RESULT-(\d+)\.md$/);
-  if (tsMatch) {
-    const snapshotFile = `TASK-${tsMatch[1]}.md`;
-    const snapshotPath = path.join(projectRoot, "tasks", taskId, snapshotFile);
-    if (fs.existsSync(snapshotPath)) {
-      fs.unlinkSync(snapshotPath);
-    }
+  // Delete the run directory
+  const runDir = path.join(projectRoot, "tasks", taskId, runId);
+  if (fs.existsSync(runDir)) {
+    fs.rmSync(runDir, { recursive: true, force: true });
   }
 
   return true;

package/src/types.ts

@@ -53,6 +53,8 @@ export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
 export interface TaskStatus {
   running_state: TaskRunningState;
   time_stamp: number;
+  /** PID of the palmier run process (used on Windows to kill the process tree). */
+  pid?: number;
   /** Set when the task has `requires_confirmation` and is awaiting user approval. */
   pending_confirmation?: boolean;
   /** Set when the agent requests permissions not yet granted. Contains the permissions needed. */
@@ -65,7 +67,7 @@ export interface TaskStatus {
 
 export interface HistoryEntry {
   task_id: string;
-  result_file: string;
+  run_id: string;
 }
 
 export interface RequiredPermission {
@@ -73,6 +75,14 @@ export interface RequiredPermission {
   description: string;
 }
 
+export interface ConversationMessage {
+  role: "assistant" | "user" | "status";
+  time: number;
+  content: string;
+  type?: "input" | "permission" | "confirmation" | "started" | "finished" | "failed" | "aborted" | "stopped";
+  attachments?: string[];
+}
+
 export interface RpcMessage {
   method: string;
   params: Record<string, unknown>;

package/dist/commands/mcpserver.d.ts

@@ -1,2 +0,0 @@
-export declare function mcpserverCommand(): Promise<void>;
-//# sourceMappingURL=mcpserver.d.ts.map