palmier 0.4.3 → 0.4.4

package/src/commands/run.ts

@@ -4,7 +4,7 @@ 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, appendResultMessage, finalizeResultFrontmatter } 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 } from "../agents/shared-prompt.js";
@@ -22,7 +22,7 @@ interface InvocationContext {
   agent: AgentTool;
   task: ParsedTask;
   taskDir: string;
-  resultFileName: string;
+  runId: string;
   guiEnv: Record<string, string>;
   nc: NatsConnection | undefined;
   config: HostConfig;
@@ -51,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, PALMIER_RESULT_FILE: ctx.resultFileName },
+      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,
@@ -118,7 +118,7 @@ async function invokeAgentWithRetry(
 /**
  * Strip [PALMIER_*] marker lines from agent output.
  */
-function stripPalmierMarkers(output: string): string {
+export function stripPalmierMarkers(output: string): string {
   return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
 }
 
@@ -127,22 +127,24 @@ function stripPalmierMarkers(output: string): string {
  */
 async function appendAndNotify(
   ctx: InvocationContext,
-  msg: Parameters<typeof appendResultMessage>[2],
+  msg: Parameters<typeof appendRunMessage>[2],
 ): Promise<void> {
-  appendResultMessage(ctx.taskDir, ctx.resultFileName, msg);
-  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated" });
+  appendRunMessage(ctx.taskDir, ctx.runId, msg);
+  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
 
 /**
- * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ * Find the latest run dir that has no status messages yet (just created by the RPC handler).
  */
-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;
+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;
 }
 
 /**
@@ -167,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 () => {
@@ -184,19 +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);
-
-    // Status: started
-    appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "started" });
-    await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+    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) {
@@ -205,22 +196,21 @@ export async function runCommand(taskId: string): Promise<void> {
       await publishConfirmResolved(nc, config, taskId, resolvedStatus);
       if (!confirmed) {
         console.log("Task aborted by user.");
-        appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "aborted" });
-        finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: "aborted" });
-        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.");
-      appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: "confirmation" });
-      await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated" });
+      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, resultFileName, guiEnv, nc, config, taskId,
+      agent, task, taskDir, runId, guiEnv, nc, config, taskId,
       transientPermissions: [],
     };
 
@@ -228,9 +218,8 @@ export async function runCommand(taskId: string): Promise<void> {
       // Command-triggered mode
       const result = await runCommandTriggeredMode(ctx);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-      finalizeResultFrontmatter(taskDir, resultFileName, { end_time: result.endTime, running_state: outcome });
-      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 — add user prompt as first message
@@ -242,23 +231,21 @@ export async function runCommand(taskId: string): Promise<void> {
 
       const result = await invokeAgentWithRetry(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-      finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-      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.`);
     }
   } catch (err) {
     console.error(`Task ${taskId} failed:`, err);
     const outcome = resolveOutcome(taskDir, "failed");
     const errorMsg = err instanceof Error ? err.message : String(err);
-    appendResultMessage(taskDir, resultFileName, {
+    appendRunMessage(taskDir, runId, {
       role: "assistant",
       time: Date.now(),
       content: errorMsg,
     });
-    appendResultMessage(taskDir, resultFileName, { role: "status", time: Date.now(), content: "", type: outcome });
-    finalizeResultFrontmatter(taskDir, resultFileName, { end_time: Date.now(), running_state: outcome });
-    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);
     process.exitCode = 1;
   } finally {
     await cleanup();
@@ -284,8 +271,8 @@ async function runCommandTriggeredMode(
   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;
@@ -297,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");
@@ -404,7 +391,7 @@ async function publishTaskEvent(
   taskId: string,
   eventType: TaskRunningState,
   taskName?: string,
-  resultFile?: string,
+  runId?: string,
 ): Promise<void> {
   writeTaskStatus(taskDir, {
     running_state: eventType,
@@ -414,7 +401,7 @@ async function publishTaskEvent(
 
   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);
 }
 

package/src/commands/serve.ts

@@ -4,7 +4,7 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { createRpcHandler } from "../rpc-handler.js";
 import { startNatsTransport } from "../transports/nats-transport.js";
-import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile, appendResultMessage } from "../task.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
 import { detectAgents } from "../agents/agent.js";
@@ -17,46 +17,11 @@ const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 
 /**
- * Mark a stuck task as failed: update status.json, write RESULT, append history,
- * and broadcast the failure event.
- */
-async function markTaskFailed(
-  config: HostConfig,
-  nc: NatsConnection | undefined,
-  taskId: string,
-  reason: string,
-): Promise<void> {
-  const taskDir = getTaskDir(config.projectRoot, taskId);
-  const status = readTaskStatus(taskDir);
-  if (!status || status.running_state !== "started") return;
-
-  console.log(`[monitor] Task ${taskId} ${reason}, marking as failed.`);
-  const endTime = Date.now();
-  writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-
-  let taskName = taskId;
-  try {
-    const task = parseTaskFile(taskDir);
-    taskName = task.frontmatter.name || taskId;
-  } catch { /* use taskId as fallback */ }
-
-  const resultFileName = `RESULT-${endTime}.md`;
-  const content = `---\ntask_name: ${taskName}\nrunning_state: failed\nstart_time: ${status.time_stamp}\nend_time: ${endTime}\ntask_file: \n---\n\n`;
-  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-  appendResultMessage(taskDir, resultFileName, {
-    role: "assistant",
-    time: endTime,
-    content: reason,
-  });
-  appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-
-  const payload: Record<string, unknown> = { event_type: "running-state", running_state: "failed", name: taskName };
-  await publishHostEvent(nc, config.hostId, taskId, payload);
-}
-
-/**
- * Scan all tasks for any stuck in "start" state whose process is no longer alive.
+ * Scan all tasks for any stuck in "started" state whose process is no longer alive.
  * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ *
+ * Since run.ts creates the RESULT file and history entry at start, we just need to
+ * finalize the existing RESULT file, append a failed status entry, and broadcast.
  */
 async function checkStaleTasks(
   config: HostConfig,
@@ -80,7 +45,35 @@ async function checkStaleTasks(
     // Ask the system scheduler if the task is still running
     if (platform.isTaskRunning(taskId)) continue;
 
-    await markTaskFailed(config, nc, taskId, "Task process exited unexpectedly");
+    console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
+    const endTime = Date.now();
+    writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
+
+    // Find the latest run directory (created by run.ts at start)
+    const runId = fs.readdirSync(taskDir)
+      .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+      .sort()
+      .pop();
+
+    if (runId) {
+      appendRunMessage(taskDir, runId, {
+        role: "status",
+        time: endTime,
+        content: "",
+        type: "failed",
+      });
+    }
+
+    let taskName = taskId;
+    try {
+      taskName = parseTaskFile(taskDir).frontmatter.name || taskId;
+    } catch { /* use taskId as fallback */ }
+
+    await publishHostEvent(nc, config.hostId, taskId, {
+      event_type: "running-state",
+      running_state: "failed",
+      name: taskName,
+    });
   }
 }
 

package/src/platform/linux.ts

@@ -5,6 +5,8 @@ import { execSync, exec } from "child_process";
 import { promisify } from "util";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
+import { loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 
 const execAsync = promisify(exec);
 
@@ -230,20 +232,28 @@ WantedBy=timers.target
   }
 
   isTaskRunning(taskId: string): boolean {
+    // 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";
-    } catch {
-      return false;
-    }
+      if (state === "active" || state === "activating") return true;
+    } 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(): Record<string, string> {

package/src/platform/windows.ts

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