palmier 0.4.2 → 0.4.4

package/src/agents/agent-instructions.md

@@ -0,0 +1,40 @@
+You are an AI agent executing a task on behalf of the user via the Palmier platform. Follow these instructions carefully.
+
+## Reporting Output
+
+If you generate report or output files, print each file path on its own line prefixed with [PALMIER_REPORT]:
+[PALMIER_REPORT] report.md
+[PALMIER_REPORT] summary.md
+
+## Completion
+
+When you are done, output exactly one of these markers as the very last line:
+- Success: [PALMIER_TASK_SUCCESS]
+- Failure: [PALMIER_TASK_FAILURE]
+Do not wrap them in code blocks or add text on the same line.
+
+## Permissions
+
+If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]:
+[PALMIER_PERMISSION] Read | Read file contents from the repository
+[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
+[PALMIER_PERMISSION] Write | Write generated output files
+
+## CLI Commands
+
+You have access to the following palmier CLI commands:
+
+**Requesting user input** — If you need any information you do not have (credentials, configuration values, preferences, clarifications, etc.) or the task explicitly asks you to get input from the user, do NOT fail the task. Instead, request it:
+```
+palmier request-input --description "What is the database connection string?" --description "What is the API key?"
+```
+The command blocks until the user responds and prints each value on its own line. If the user aborts, the command exits with a non-zero status.
+
+**Sending push notifications** — If you need to send a push notification to the user:
+```
+palmier notify --title "Task Complete" --body "The deployment finished successfully."
+```
+
+---
+
+The task to execute follows below.

package/src/agents/claude.ts

@@ -13,8 +13,8 @@ export class ClaudeAgent implements AgentTool {
   }
 
   getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
-    const args = ["--permission-mode", "acceptEdits", "--append-system-prompt", AGENT_INSTRUCTIONS, "-p"];
+    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    const args = ["--permission-mode", "acceptEdits", "-p"];
 
     const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
     for (const p of allPerms) {
@@ -31,11 +31,6 @@ export class ClaudeAgent implements AgentTool {
     } catch {
       return false;
     }
-    try {
-      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { stdio: "ignore", shell: SHELL });
-    } catch {
-      // MCP registration is best-effort; agent still works without it
-    }
     return true;
   }
 }

package/src/agents/codex.ts

@@ -34,11 +34,6 @@ export class CodexAgent implements AgentTool {
     } catch {
       return false;
     }
-    try {
-      execSync("codex mcp add palmier palmier mcpserver", { stdio: "ignore", shell: SHELL });
-    } catch {
-      // MCP registration is best-effort; agent still works without it
-    }
     return true;
   }
 }

package/src/agents/copilot.ts

@@ -1,6 +1,3 @@
-import * as fs from "fs";
-import * as path from "path";
-import { homedir } from "os";
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
@@ -34,22 +31,6 @@ export class CopilotAgent implements AgentTool {
     } catch {
       return false;
     }
-    // Register Palmier MCP server in ~/.copilot/mcp-config.json
-    try {
-      const configDir = path.join(homedir(), ".copilot");
-      const configFile = path.join(configDir, "mcp-config.json");
-      let config: Record<string, unknown> = {};
-      if (fs.existsSync(configFile)) {
-        config = JSON.parse(fs.readFileSync(configFile, "utf-8")) as Record<string, unknown>;
-      }
-      const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
-      servers.palmier = { command: "palmier", args: ["mcpserver"] };
-      config.mcpServers = servers;
-      fs.mkdirSync(configDir, { recursive: true });
-      fs.writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
-    } catch {
-      // MCP registration is best-effort
-    }
     return true;
   }
 }

package/src/agents/gemini.ts

@@ -35,11 +35,6 @@ export class GeminiAgent implements AgentTool {
     } catch {
       return false;
     }
-    try {
-      execSync("gemini mcp add --scope user palmier palmier mcpserver", { stdio: "ignore", shell: SHELL });
-    } catch {
-      // MCP registration is best-effort; agent still works without it
-    }
     return true;
   }
 }

package/src/agents/shared-prompt.ts

@@ -1,28 +1,20 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 /**
  * Instructions prepended or injected as system prompt for every task invocation.
  * Instructs the agent to output structured markers so palmier can determine
  * the task outcome, report files, and permission/input requests.
  */
-export const AGENT_INSTRUCTIONS = `If you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.
-[PALMIER_REPORT] report.md
-[PALMIER_REPORT] summary.md
-
-When you are done, output exactly one of these markers as the very last line:
-- Success: [PALMIER_TASK_SUCCESS]
-- Failure: [PALMIER_TASK_FAILURE]
-Do not wrap them in code blocks or add text on the same line.
-
-If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]: e.g.
-[PALMIER_PERMISSION] Read | Read file contents from the repository
-[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
-[PALMIER_PERMISSION] Write | Write generated output files
-
-If the task requires information from the user that you do not have (such as credentials, connection strings, API keys, or configuration values), print each required input on its own line prefixed with [PALMIER_INPUT]: e.g.
-[PALMIER_INPUT] What is the database connection string?
-[PALMIER_INPUT] What is the API key for the external service?`;
+export const AGENT_INSTRUCTIONS = fs.readFileSync(
+  path.join(__dirname, "agent-instructions.md"),
+  "utf-8",
+);
 
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
 export const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";
 export const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
-export const TASK_INPUT_PREFIX = "[PALMIER_INPUT]";

package/src/commands/notify.ts

@@ -0,0 +1,44 @@
+import { StringCodec } from "nats";
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.js";
+
+/**
+ * Send a push notification to the user via NATS.
+ * Usage: palmier notify --title "Title" --body "Body text"
+ */
+export async function notifyCommand(opts: { title: string; body: string }): Promise<void> {
+  const config = loadConfig();
+  const nc = await connectNats(config);
+
+  if (!nc) {
+    console.error("Error: NATS connection required for push notifications.");
+    process.exit(1);
+  }
+
+  const sc = StringCodec();
+  const payload = {
+    hostId: config.hostId,
+    title: opts.title,
+    body: opts.body,
+  };
+
+  try {
+    const subject = `host.${config.hostId}.push.send`;
+    const reply = await nc.request(subject, sc.encode(JSON.stringify(payload)), {
+      timeout: 15_000,
+    });
+    const result = JSON.parse(sc.decode(reply.data)) as { ok?: boolean; error?: string };
+
+    if (result.ok) {
+      console.log("Push notification sent successfully.");
+    } else {
+      console.error(`Failed to send push notification: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`Error sending push notification: ${err}`);
+    process.exit(1);
+  } finally {
+    await nc.drain();
+  }
+}

package/src/commands/request-input.ts

@@ -0,0 +1,51 @@
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile, appendRunMessage } from "../task.js";
+import { requestUserInput, publishInputResolved } from "../user-input.js";
+
+/**
+ * Request input from the user and print responses to stdout.
+ * Usage: palmier request-input --description "Question 1" --description "Question 2"
+ *
+ * Requires PALMIER_TASK_ID and PALMIER_RUN_DIR environment variables.
+ */
+export async function requestInputCommand(opts: { description: string[] }): Promise<void> {
+  const taskId = process.env.PALMIER_TASK_ID;
+  if (!taskId) {
+    console.error("Error: PALMIER_TASK_ID environment variable is not set.");
+    process.exit(1);
+  }
+
+  const config = loadConfig();
+  const nc = await connectNats(config);
+  const taskDir = getTaskDir(config.projectRoot, taskId);
+  const task = parseTaskFile(taskDir);
+  const runId = process.env.PALMIER_RUN_DIR?.split(/[/\\]/).pop();
+
+  try {
+    const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, opts.description);
+    await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
+
+    if (response === "aborted") {
+      if (runId) {
+        appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Input request aborted.", type: "input" });
+      }
+      console.error("User aborted the input request.");
+      process.exit(1);
+    }
+
+    if (runId) {
+      const lines = opts.description.map((desc, i) => `**${desc}** ${response[i]}`);
+      appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: lines.join("\n"), type: "input" });
+    }
+
+    for (let i = 0; i < opts.description.length; i++) {
+      console.log(response[i]);
+    }
+  } catch (err) {
+    console.error(`Error requesting user input: ${err}`);
+    process.exit(1);
+  } finally {
+    if (nc) await nc.drain();
+  }
+}

package/src/commands/run.ts

@@ -4,42 +4,16 @@ import * as readline from "readline";
 import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
-import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import type { AgentTool } from "../agents/agent.js";
 import { publishHostEvent } from "../events.js";
-import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
+import { waitForUserInput } from "../user-input.js";
 import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
 import type { NatsConnection } from "nats";
 
-/**
- * Write a time-stamped RESULT file with frontmatter.
- * Always generated, even for abort/fail.
- */
-
-/**
- * Update an existing result file with the final outcome.
- */
-function finalizeResultFile(
-  taskDir: string,
-  resultFileName: string,
-  taskName: string,
-  taskSnapshotName: string,
-  runningState: string,
-  startTime: number,
-  endTime: number,
-  output: string,
-  reportFiles: string[],
-  requiredPermissions: RequiredPermission[],
-): void {
-  const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
-  const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
-  const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
-  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-}
-
 /**
  * Shared context for agent invocation retry loops.
  * Passed around to avoid threading many individual parameters.
@@ -48,6 +22,7 @@ interface InvocationContext {
   agent: AgentTool;
   task: ParsedTask;
   taskDir: string;
+  runId: string;
   guiEnv: Record<string, string>;
   nc: NatsConnection | undefined;
   config: HostConfig;
@@ -57,10 +32,7 @@ interface InvocationContext {
 }
 
 interface InvocationResult {
-  output: string;
   outcome: TaskRunningState;
-  reportFiles: string[];
-  requiredPermissions: RequiredPermission[];
 }
 
 /**
@@ -79,8 +51,8 @@ async function invokeAgentWithRetry(
   while (true) {
     const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
     const result = await spawnCommand(command, args, {
-      cwd: ctx.taskDir,
-      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id },
+      cwd: getRunDir(ctx.taskDir, ctx.runId),
+      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -90,13 +62,27 @@ async function invokeAgentWithRetry(
     const reportFiles = parseReportFiles(result.output);
     const requiredPermissions = parsePermissions(result.output);
 
+    // Append assistant message for this invocation
+    await appendAndNotify(ctx, {
+      role: "assistant",
+      time: Date.now(),
+      content: stripPalmierMarkers(result.output),
+      attachments: reportFiles.length > 0 ? reportFiles : undefined,
+    });
+
     // Permission retry
     if (outcome === "failed" && requiredPermissions.length > 0) {
       const response = await requestPermission(ctx.nc, ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
       await publishPermissionResolved(ctx.nc, ctx.config, ctx.taskId, response);
 
       if (response === "aborted") {
-        return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
+        await appendAndNotify(ctx, {
+          role: "user",
+          time: Date.now(),
+          content: "Permissions denied. Task aborted.",
+          type: "permission",
+        });
+        return { outcome: "failed" };
       }
 
       const newPerms = requiredPermissions.filter(
@@ -104,6 +90,14 @@ async function invokeAgentWithRetry(
           && !ctx.transientPermissions.some((ep) => ep.name === rp.name),
       );
 
+      // Append user message for permission grant
+      await appendAndNotify(ctx, {
+        role: "user",
+        time: Date.now(),
+        content: `Permissions granted: ${newPerms.map((p) => p.name).join(", ")}`,
+        type: "permission",
+      });
+
       if (response === "granted_all") {
         ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
         invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
@@ -116,36 +110,41 @@ async function invokeAgentWithRetry(
       continue;
     }
 
-    // Input retry
-    const inputRequests = parseInputRequests(result.output);
-    if (outcome === "failed" && inputRequests.length > 0) {
-      const response = await requestUserInput(ctx.nc, ctx.config, ctx.taskId, ctx.task.frontmatter.name, ctx.taskDir, inputRequests);
-      await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided");
-
-      if (response === "aborted") {
-        return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
-      }
-
-      const inputLines = inputRequests.map((desc, i) => `- ${desc} → ${response[i]}`).join("\n");
-      retryPrompt = `The user provided the following inputs:\n${inputLines}\nPlease continue with these values.`;
-      continue;
-    }
-
     // Normal completion (success or non-retryable failure)
-    return { output: result.output, outcome, reportFiles, requiredPermissions };
+    return { outcome };
   }
 }
 
 /**
- * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ * Strip [PALMIER_*] marker lines from agent output.
  */
-function findStartedResultFile(taskDir: string): string | null {
-  const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
-  for (const file of files) {
-    const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
-    if (content.includes("running_state: started")) return file;
-  }
-  return null;
+export function stripPalmierMarkers(output: string): string {
+  return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
+}
+
+/**
+ * Append a conversation message to the RESULT file and notify connected clients.
+ */
+async function appendAndNotify(
+  ctx: InvocationContext,
+  msg: Parameters<typeof appendRunMessage>[2],
+): Promise<void> {
+  appendRunMessage(ctx.taskDir, ctx.runId, msg);
+  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+}
+
+/**
+ * Find the latest run dir that has no status messages yet (just created by the RPC handler).
+ */
+function findLatestPendingRunId(taskDir: string): string | null {
+  const dirs = fs.readdirSync(taskDir)
+    .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+    .sort();
+  if (dirs.length === 0) return null;
+  const latest = dirs[dirs.length - 1];
+  const messages = readRunMessages(taskDir, latest);
+  const hasStatus = messages.some((m) => m.role === "status");
+  return hasStatus ? null : latest;
 }
 
 /**
@@ -170,15 +169,11 @@ export async function runCommand(taskId: string): Promise<void> {
   let nc: NatsConnection | undefined;
   const taskName = task.frontmatter.name;
 
-  // Check for an existing "started" result file (created by the RPC handler)
-  const existingResult = findStartedResultFile(taskDir);
-  const startTime = existingResult ? parseInt(existingResult.replace("RESULT-", "").replace(".md", ""), 10) : Date.now();
-  const resultFileName = existingResult ?? createResultFile(taskDir, taskName, startTime);
-
-  // Snapshot the task file at run time
-  const taskSnapshotName = `TASK-${startTime}.md`;
-  if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
-    fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+  // Use existing run dir if just created by RPC, otherwise create a new one
+  const existingRunId = findLatestPendingRunId(taskDir);
+  const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now());
+  if (!existingRunId) {
+    appendHistory(config.projectRoot, { task_id: taskId, run_id: runId });
   }
 
   const cleanup = async () => {
@@ -187,15 +182,12 @@ export async function runCommand(taskId: string): Promise<void> {
     }
   };
 
-  if (!existingResult) {
-    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-  }
-
   try {
     nc = await connectNats(config);
 
-    // Mark as started immediately
-    await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
+    await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, runId);
+    appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "started" });
+    await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
 
     // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
@@ -204,20 +196,21 @@ export async function runCommand(taskId: string): Promise<void> {
       await publishConfirmResolved(nc, config, taskId, resolvedStatus);
       if (!confirmed) {
         console.log("Task aborted by user.");
-        const endTime = Date.now();
-        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
+        appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
+        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, runId);
         await cleanup();
         return;
       }
       console.log("Task confirmed by user.");
+      appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "confirmation" });
+      await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
     }
 
     // Shared invocation context
     const guiEnv = getPlatform().getGuiEnv();
     const agent = getAgent(task.frontmatter.agent);
     const ctx: InvocationContext = {
-      agent, task, taskDir, guiEnv, nc, config, taskId,
+      agent, task, taskDir, runId, guiEnv, nc, config, taskId,
       transientPermissions: [],
     };
 
@@ -225,36 +218,34 @@ export async function runCommand(taskId: string): Promise<void> {
       // Command-triggered mode
       const result = await runCommandTriggeredMode(ctx);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+      appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
       console.log(`Task ${taskId} completed (command-triggered).`);
     } else {
-      // Standard execution
+      // Standard execution — add user prompt as first message
+      await appendAndNotify(ctx, {
+        role: "user",
+        time: Date.now(),
+        content: task.body || task.frontmatter.user_prompt,
+      });
+
       const result = await invokeAgentWithRetry(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
-
-      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
-
-      if (result.reportFiles.length > 0) {
-        await publishHostEvent(nc, config.hostId, taskId, {
-          event_type: "report-generated",
-          name: taskName,
-          report_files: result.reportFiles,
-          running_state: outcome,
-          result_file: resultFileName,
-        });
-      }
-
+      appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
       console.log(`Task ${taskId} completed.`);
     }
   } catch (err) {
     console.error(`Task ${taskId} failed:`, err);
-    const endTime = Date.now();
     const outcome = resolveOutcome(taskDir, "failed");
     const errorMsg = err instanceof Error ? err.message : String(err);
-    finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
+    appendRunMessage(taskDir, runId, {
+      role: "assistant",
+      time: Date.now(),
+      content: errorMsg,
+    });
+    appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
     process.exitCode = 1;
   } finally {
     await cleanup();
@@ -275,13 +266,13 @@ const MAX_LINE_LENGTH = 200_000;
  */
 async function runCommandTriggeredMode(
   ctx: InvocationContext,
-): Promise<{ outcome: TaskRunningState; endTime: number; output: string }> {
+): Promise<{ outcome: TaskRunningState; endTime: number }> {
   const commandStr = ctx.task.frontmatter.command!;
   console.log(`[command-triggered] Spawning: ${commandStr}`);
 
   const child = spawnStreamingCommand(commandStr, {
-    cwd: ctx.taskDir,
-    env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id },
+    cwd: getRunDir(ctx.taskDir, ctx.runId),
+    env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
   });
 
   let linesProcessed = 0;
@@ -293,7 +284,7 @@ async function runCommandTriggeredMode(
   let commandExited = false;
   let resolveWhenDone: (() => void) | undefined;
 
-  const logPath = path.join(ctx.taskDir, "command-output.log");
+  const logPath = path.join(getRunDir(ctx.taskDir, ctx.runId), "command-output.log");
   function appendLog(line: string, agentOutput: string, outcome: string) {
     const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
     fs.appendFileSync(logPath, entry, "utf-8");
@@ -331,7 +322,7 @@ async function runCommandTriggeredMode(
     } else {
       invocationsFailed++;
     }
-    appendLog(line, result.output, result.outcome);
+    appendLog(line, "", result.outcome);
   }
 
   async function drainQueue(): Promise<void> {
@@ -390,15 +381,7 @@ async function runCommandTriggeredMode(
   }
 
   const endTime = Date.now();
-  const summary = [
-    `Command: ${commandStr}`,
-    `Exit code: ${exitCode}`,
-    `Lines processed: ${linesProcessed}`,
-    `Agent invocations succeeded: ${invocationsSucceeded}`,
-    `Agent invocations failed: ${invocationsFailed}`,
-  ].join("\n");
-
-  return { outcome: "finished", endTime, output: summary };
+  return { outcome: "finished", endTime };
 }
 
 async function publishTaskEvent(
@@ -408,16 +391,17 @@ async function publishTaskEvent(
   taskId: string,
   eventType: TaskRunningState,
   taskName?: string,
-  resultFile?: string,
+  runId?: string,
 ): Promise<void> {
   writeTaskStatus(taskDir, {
     running_state: eventType,
     time_stamp: Date.now(),
+    ...(eventType === "started" ? { pid: process.pid } : {}),
   });
 
   const payload: Record<string, unknown> = { event_type: "running-state", running_state: eventType };
   if (taskName) payload.name = taskName;
-  if (resultFile) payload.result_file = resultFile;
+  if (runId) payload.run_id = runId;
   await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 
@@ -534,21 +518,6 @@ export function parsePermissions(output: string): RequiredPermission[] {
   return perms;
 }
 
-/**
- * Extract user input requests from agent output.
- * Looks for lines matching: [PALMIER_INPUT] <description>
- */
-export function parseInputRequests(output: string): string[] {
-  const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
-  const inputs: string[] = [];
-  let match;
-  while ((match = regex.exec(output)) !== null) {
-    const desc = match[1].trim();
-    if (desc) inputs.push(desc);
-  }
-  return inputs;
-}
-
 /**
  * Parse the agent's output for success/failure markers.
  * Falls back to "finished" if no marker is found.