palmier 0.4.2 → 0.4.4

package/dist/rpc-handler.js

@@ -4,57 +4,88 @@ 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");
 /**
- * Parse RESULT frontmatter into a metadata object.
+ * Parse RESULT frontmatter and conversation messages.
  */
 function parseResultFrontmatter(raw) {
     const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!fmMatch)
-        return { content: raw };
+        return { messages: [] };
     const meta = {};
-    const requiredPermissions = [];
     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) => 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;
     }
-    const reportFiles = meta.report_files
-        ? meta.report_files.split(",").map((f) => 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) {
+    const delimiterRegex = /<!-- palmier:message\s+(.*?)\s*-->/g;
+    const messages = [];
+    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");
+        const time = Number(parseAttr(attrs, "time") ?? "0");
+        const type = parseAttr(attrs, "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, name) {
+    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.
@@ -85,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.
  */
@@ -226,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], {
@@ -236,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;
@@ -244,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;
@@ -255,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);
                 }
@@ -288,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" });
@@ -317,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 });
@@ -339,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,
@@ -347,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 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": {
+            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/spawn-command.d.ts

@@ -1,4 +1,4 @@
-import type { ChildProcess } from "child_process";
+import { type ChildProcess } from "child_process";
 export interface SpawnStreamingOptions {
     cwd: string;
     env?: Record<string, string>;

package/dist/spawn-command.js

@@ -1,4 +1,16 @@
 import crossSpawn from "cross-spawn";
+import { execFileSync } from "child_process";
+/** Kill a child process and its entire tree on Windows; plain kill elsewhere. */
+function treeKill(child) {
+    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();
+}
 /**
  * Spawn a command with shell interpretation, returning the ChildProcess
  * with stdout piped for line-by-line reading.
@@ -50,7 +62,7 @@ export function spawnCommand(command, args, opts) {
         let timer;
         if (opts.timeout) {
             timer = setTimeout(() => {
-                child.kill();
+                treeKill(child);
                 reject(new Error("command timed out"));
             }, opts.timeout);
         }

package/dist/task.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedTask, TaskStatus, HistoryEntry } from "./types.js";
+import type { ParsedTask, TaskStatus, HistoryEntry, ConversationMessage } from "./types.js";
 /**
  * Parse a TASK.md file from the given task directory.
  */
@@ -39,20 +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;
+/**
+ * Get the path to a run directory.
+ */
+export declare function getRunDir(taskDir: string, runId: string): string;
+/**
+ * Append a conversation message to a run's TASKRUN.md file.
+ */
+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,16 +130,69 @@ 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`;
-    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;
+}
+/**
+ * Get the path to a run directory.
+ */
+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}"`);
+    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, 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) } : {}),
+        });
+    }
+    return messages;
 }
 /**
  * Append a history entry to the project-level history.jsonl file.
@@ -149,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;
@@ -162,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 */ }
@@ -172,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;
 }

package/dist/types.d.ts

@@ -48,6 +48,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. */
@@ -59,12 +61,19 @@ export interface TaskStatus {
 }
 export interface HistoryEntry {
     task_id: string;
-    result_file: string;
+    run_id: string;
 }
 export interface RequiredPermission {
     name: string;
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",
@@ -20,13 +20,12 @@
   },
   "scripts": {
     "dev": "tsx src/index.ts",
-    "build": "tsc && node -e \"require('fs').cpSync('src/commands/plan-generation.md','dist/commands/plan-generation.md')\"",
+    "build": "tsc && node -e \"require('fs').cpSync('src/commands/plan-generation.md','dist/commands/plan-generation.md');require('fs').cpSync('src/agents/agent-instructions.md','dist/agents/agent-instructions.md')\"",
     "test": "tsx --test test/**/*.test.ts",
     "prepare": "npm run build",
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^13.1.0",
     "cross-spawn": "^7.0.6",
     "dotenv": "^16.4.7",