palmier 0.4.3 → 0.4.5

package/src/platform/windows.ts

@@ -13,14 +13,6 @@ const DAEMON_TASK_NAME = "PalmierDaemon";
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 const DAEMON_VBS_FILE = path.join(CONFIG_DIR, "daemon.vbs");
 
-/**
- * Build the /tr value for schtasks: a single string with quoted paths
- * so Task Scheduler can invoke node with the palmier script + subcommand.
- */
-function schtasksTr(...subcommand: string[]): string {
-  const script = process.argv[1] || "palmier";
-  return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
-}
 
 const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 
@@ -169,7 +161,15 @@ export class WindowsPlatform implements PlatformService {
   installTaskTimer(config: HostConfig, task: ParsedTask): void {
     const taskId = task.frontmatter.id;
     const tn = schtasksTaskName(taskId);
-    const tr = schtasksTr("run", taskId);
+    const script = process.argv[1] || "palmier";
+
+    // Write a VBS launcher so the task runs without a visible console window
+    const vbsPath = path.join(CONFIG_DIR, `task-${taskId}.vbs`);
+    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" run ${taskId}", 0, True`;
+    fs.writeFileSync(vbsPath, vbs, "utf-8");
+
+    const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+    const tr = `"${wscript}" "${vbsPath}"`;
 
     // Build trigger XML elements
     const triggerElements: string[] = [];
@@ -213,6 +213,7 @@ export class WindowsPlatform implements PlatformService {
     } catch {
       // Task might not exist — that's fine
     }
+    try { fs.unlinkSync(path.join(CONFIG_DIR, `task-${taskId}.vbs`)); } catch { /* ignore */ }
   }
 
   async startTask(taskId: string): Promise<void> {
@@ -250,16 +251,38 @@ export class WindowsPlatform implements PlatformService {
   }
 
   isTaskRunning(taskId: string): boolean {
+    // Check Task Scheduler first (for scheduled/on-demand runs)
     const tn = schtasksTaskName(taskId);
     try {
       const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
         encoding: "utf-8",
         windowsHide: true,
       });
-      return out.includes('"Running"');
-    } catch {
-      return false;
-    }
+      if (out.includes('"Running"')) return true;
+    } catch { /* task may not exist in scheduler */ }
+
+    // Fall back to PID check (for follow-up runs spawned directly, not via schtasks)
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        // tasklist exits 0 if the PID is found
+        execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/nh"], {
+          encoding: "utf-8",
+          windowsHide: true,
+          stdio: "pipe",
+        });
+        // tasklist always exits 0; check if output contains the PID
+        const out = execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/fo", "CSV", "/nh"], {
+          encoding: "utf-8",
+          windowsHide: true,
+          stdio: "pipe",
+        });
+        if (out.includes(`"${status.pid}"`)) return true;
+      }
+    } catch { /* ignore */ }
+
+    return false;
   }
 
   getGuiEnv(): Record<string, string> {

package/src/rpc-handler.ts

@@ -2,16 +2,18 @@ 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 { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -37,13 +39,27 @@ function parseResultFrontmatter(raw: string): Record<string, unknown> {
 
   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;
+  }
+
   return {
     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,
+    running_state: runningState,
+    start_time: startedMsg?.time || undefined,
+    end_time: terminalMsg?.time || undefined,
   };
 }
 
@@ -124,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.
  */
@@ -298,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";
@@ -310,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": {
@@ -319,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}`);
@@ -331,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) {
@@ -364,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" });
@@ -395,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 });
@@ -421,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,
@@ -430,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 messages from list response
             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/task.ts

@@ -148,28 +148,35 @@ 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\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;
 }
 
 /**
- * Append a conversation message to a RESULT file.
+ * Get the path to a run directory.
  */
-export function appendResultMessage(
+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,
-  resultFile: string,
+  runId: string,
   msg: ConversationMessage,
 ): void {
   const attrs = [`role="${msg.role}"`, `time="${msg.time}"`];
@@ -178,35 +185,44 @@ export function appendResultMessage(
 
   const delimiter = `<!-- palmier:message ${attrs.join(" ")} -->`;
   const entry = `${delimiter}\n\n${msg.content}\n\n`;
-  fs.appendFileSync(path.join(taskDir, resultFile), entry, "utf-8");
+  fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
 }
 
 /**
- * Update frontmatter fields in a RESULT file without touching the body.
+ * Read conversation messages from a run's TASKRUN.md file.
  */
-export function finalizeResultFrontmatter(
-  taskDir: string,
-  resultFile: string,
-  updates: { end_time?: number; running_state?: string },
-): void {
-  const filePath = path.join(taskDir, resultFile);
-  const raw = fs.readFileSync(filePath, "utf-8");
-  const fmEnd = raw.indexOf("\n---\n", 4); // skip opening ---
-  if (fmEnd === -1) return;
-
-  let frontmatter = raw.slice(0, fmEnd);
-  const body = raw.slice(fmEnd);
-
-  for (const [key, value] of Object.entries(updates)) {
-    const regex = new RegExp(`^${key}:.*$`, "m");
-    if (regex.test(frontmatter)) {
-      frontmatter = frontmatter.replace(regex, `${key}: ${value}`);
-    } else {
-      frontmatter += `\n${key}: ${value}`;
-    }
+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) } : {}),
+    });
   }
-
-  fs.writeFileSync(filePath, frontmatter + body, "utf-8");
+  return messages;
 }
 
 /**
@@ -218,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;
@@ -236,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);
@@ -246,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

@@ -67,7 +67,7 @@ export interface TaskStatus {
 
 export interface HistoryEntry {
   task_id: string;
-  result_file: string;
+  run_id: string;
 }
 
 export interface RequiredPermission {
@@ -79,7 +79,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[];
 }
 

package/test/agent-output-parsing.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { parseTaskOutcome, parseReportFiles, parsePermissions, parseInputRequests } from "../src/commands/run.js";
+import { parseTaskOutcome, parseReportFiles, parsePermissions } from "../src/commands/run.js";
 
 describe("parseTaskOutcome", () => {
   it("returns 'finished' for success marker", () => {
@@ -59,16 +59,3 @@ describe("parsePermissions", () => {
   });
 });
 
-describe("parseInputRequests", () => {
-  it("extracts input descriptions", () => {
-    const output = "[PALMIER_INPUT] What is the API key?\n[PALMIER_INPUT] Database connection string?";
-    assert.deepEqual(parseInputRequests(output), [
-      "What is the API key?",
-      "Database connection string?",
-    ]);
-  });
-
-  it("returns empty array when no inputs", () => {
-    assert.deepEqual(parseInputRequests("no inputs"), []);
-  });
-});