palmier 0.4.3 → 0.4.5

package/dist/platform/linux.js

@@ -3,6 +3,8 @@ import * as path from "path";
 import { homedir } from "os";
 import { execSync, exec } from "child_process";
 import { promisify } from "util";
+import { loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 const execAsync = promisify(exec);
 const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
 const PATH_FILE = path.join(homedir(), ".config", "palmier", "user-path");
@@ -205,18 +207,26 @@ WantedBy=timers.target
         await execAsync(`systemctl --user stop ${serviceName}`);
     }
     isTaskRunning(taskId) {
+        // 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";
+            if (state === "active" || state === "activating")
+                return true;
         }
-        catch {
-            return false;
+        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() {
         const uid = process.getuid?.();

package/dist/platform/windows.js

@@ -8,14 +8,6 @@ const TASK_PREFIX = "\\Palmier\\PalmierTask-";
 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) {
-    const script = process.argv[1] || "palmier";
-    return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
-}
 const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 /**
  * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
@@ -144,7 +136,13 @@ export class WindowsPlatform {
     installTaskTimer(config, task) {
         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 = [];
         if (task.frontmatter.triggers_enabled) {
@@ -192,6 +190,10 @@ export class WindowsPlatform {
         catch {
             // Task might not exist — that's fine
         }
+        try {
+            fs.unlinkSync(path.join(CONFIG_DIR, `task-${taskId}.vbs`));
+        }
+        catch { /* ignore */ }
     }
     async startTask(taskId) {
         const tn = schtasksTaskName(taskId);
@@ -228,17 +230,40 @@ export class WindowsPlatform {
         }
     }
     isTaskRunning(taskId) {
+        // 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"');
+            if (out.includes('"Running"'))
+                return true;
         }
-        catch {
-            return false;
+        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() {
         // Windows GUI is always available — no special env vars needed

package/dist/rpc-handler.js

@@ -4,13 +4,15 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
-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";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PLAN_GENERATION_PROMPT = fs.readFileSync(path.join(__dirname, "commands", "plan-generation.md"), "utf-8");
 /**
@@ -28,13 +30,26 @@ function parseResultFrontmatter(raw) {
         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) => m.role === "status");
+    const lastStatus = statusMessages[statusMessages.length - 1];
+    const startedMsg = statusMessages.find((m) => m.type === "started");
+    const terminalStates = ["finished", "failed", "aborted"];
+    const terminalMsg = [...statusMessages].reverse().find((m) => terminalStates.includes(m.type ?? ""));
+    // If last status is "started", determine if it's a task run or follow-up
+    let runningState;
+    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,
     };
 }
 /**
@@ -101,6 +116,8 @@ async function generatePlan(projectRoot, userPrompt, agentName) {
     }
     return { name, body };
 }
+/** Active follow-up child processes, keyed by "taskId:runId". */
+const activeFollowups = new Map();
 /**
  * Create a transport-agnostic RPC handler bound to the given config.
  */
@@ -242,8 +259,8 @@ export function createRpcHandler(config, nc) {
                 writeTaskFile(taskDir, task);
                 // 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";
                 const child = spawn(process.execPath, [script, "run", id], {
@@ -252,7 +269,7 @@ export function createRpcHandler(config, nc) {
                     windowsHide: true,
                 });
                 child.unref();
-                return { ok: true, task_id: id, result_file: resultFileName };
+                return { ok: true, task_id: id, run_id: runId };
             }
             case "task.run": {
                 const params = request.params;
@@ -260,10 +277,10 @@ export function createRpcHandler(config, nc) {
                     // 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) {
                     const e = err;
@@ -271,15 +288,145 @@ export function createRpcHandler(config, nc) {
                     return { error: `Failed to start task: ${e.stderr || e.message}` };
                 }
             }
+            case "task.followup": {
+                const params = request.params;
+                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 = [];
+                child.stdout?.on("data", (d) => chunks.push(d));
+                child.stderr?.on("data", (d) => process.stderr.write(d));
+                child.on("close", async (code) => {
+                    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) => {
+                    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;
+                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;
+                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);
                 }
@@ -304,25 +451,26 @@ export function createRpcHandler(config, nc) {
             }
             case "task.result": {
                 const params = request.params;
-                if (!params.result_file) {
-                    return { error: "result_file is required" };
+                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;
-                if (!Array.isArray(params.report_files) || params.report_files.length === 0) {
-                    return { error: "report_files must be a non-empty array" };
+                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 = [];
+                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" });
@@ -333,7 +481,7 @@ export function createRpcHandler(config, nc) {
                         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 });
@@ -355,7 +503,7 @@ export function createRpcHandler(config, nc) {
                 console.log(`[task.user_input] ${params.id} → ${params.value}`);
                 return { ok: true };
             }
-            case "activity.list": {
+            case "taskrun.list": {
                 const params = request.params;
                 const { entries, total } = readHistory(config.projectRoot, {
                     offset: params.offset ?? 0,
@@ -363,30 +511,29 @@ export function createRpcHandler(config, nc) {
                     task_id: params.task_id,
                 });
                 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": {
+            case "taskrun.delete": {
                 const params = request.params;
-                if (!params.task_id || !params.result_file) {
-                    return { error: "task_id and result_file are required" };
+                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": {
                 const error = await performUpdate();

package/dist/task.d.ts

@@ -39,31 +39,31 @@ export declare function writeTaskStatus(taskDir: string, status: TaskStatus): vo
  */
 export declare 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 declare function createResultFile(taskDir: string, taskName: string, startTime: number): string;
+export declare function createRunDir(taskDir: string, taskName: string, startTime: number): string;
 /**
- * Append a conversation message to a RESULT file.
+ * Get the path to a run directory.
  */
-export declare function appendResultMessage(taskDir: string, resultFile: string, msg: ConversationMessage): void;
+export declare function getRunDir(taskDir: string, runId: string): string;
 /**
- * Update frontmatter fields in a RESULT file without touching the body.
+ * Append a conversation message to a run's TASKRUN.md file.
  */
-export declare function finalizeResultFrontmatter(taskDir: string, resultFile: string, updates: {
-    end_time?: number;
-    running_state?: string;
-}): void;
+export declare function appendRunMessage(taskDir: string, runId: string, msg: ConversationMessage): void;
+/**
+ * Read conversation messages from a run's TASKRUN.md file.
+ */
+export declare function readRunMessages(taskDir: string, runId: string): ConversationMessage[];
 /**
  * Append a history entry to the project-level history.jsonl file.
  */
 export declare 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 declare function deleteHistoryEntry(projectRoot: string, taskId: string, resultFile: string): boolean;
+export declare function deleteHistoryEntry(projectRoot: string, taskId: string, runId: string): boolean;
 /**
  * Read history entries from history.jsonl with pagination.
  * Returns entries sorted most-recent-first.

package/dist/task.js

@@ -130,21 +130,27 @@ export function readTaskStatus(taskDir) {
     }
 }
 /**
- * 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(taskDir, taskName, startTime) {
-    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;
+export function createRunDir(taskDir, taskName, startTime) {
+    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(taskDir, resultFile, msg) {
+export function getRunDir(taskDir, runId) {
+    return path.join(taskDir, runId);
+}
+/**
+ * Append a conversation message to a run's TASKRUN.md file.
+ */
+export function appendRunMessage(taskDir, runId, msg) {
     const attrs = [`role="${msg.role}"`, `time="${msg.time}"`];
     if (msg.type)
         attrs.push(`type="${msg.type}"`);
@@ -152,29 +158,41 @@ export function appendResultMessage(taskDir, resultFile, msg) {
         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, resultFile), entry, "utf-8");
-}
-/**
- * Update frontmatter fields in a RESULT file without touching the body.
- */
-export function finalizeResultFrontmatter(taskDir, resultFile, updates) {
-    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}`;
-        }
+    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, runId) {
+    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 = [];
+    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,
+            time: Number(timeAttr),
+            content,
+            ...(typeAttr ? { type: typeAttr } : {}),
+            ...(attachmentsAttr ? { attachments: attachmentsAttr.split(",").map((f) => f.trim()).filter(Boolean) } : {}),
+        });
     }
-    fs.writeFileSync(filePath, frontmatter + body, "utf-8");
+    return messages;
 }
 /**
  * Append a history entry to the project-level history.jsonl file.
@@ -184,10 +202,10 @@ export function appendHistory(projectRoot, entry) {
     fs.appendFileSync(historyPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 /**
- * 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, taskId, resultFile) {
+export function deleteHistoryEntry(projectRoot, taskId, runId) {
     const historyPath = path.join(projectRoot, "history.jsonl");
     if (!fs.existsSync(historyPath))
         return false;
@@ -197,9 +215,9 @@ export function deleteHistoryEntry(projectRoot, taskId, resultFile) {
     for (const line of lines) {
         try {
             const entry = JSON.parse(line);
-            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 */ }
@@ -207,21 +225,11 @@ export function deleteHistoryEntry(projectRoot, taskId, resultFile) {
     }
     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;
 }