palmier 0.2.5 → 0.2.6

package/dist/commands/run.js

@@ -1,13 +1,14 @@
 import * as fs from "fs";
 import * as path from "path";
-import { spawnCommand } from "../spawn-command.js";
+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 } 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";
-import { StringCodec } from "nats";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
+import { publishHostEvent } from "../events.js";
 /**
  * Write a time-stamped RESULT file with frontmatter.
  * Always generated, even for abort/fail.
@@ -20,6 +21,74 @@ function writeResult(taskDir, taskName, taskSnapshotName, runningState, startTim
     fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
     return resultFileName;
 }
+/**
+ * Invoke the agent CLI with a retry loop for permissions and user input.
+ *
+ * Both standard and command-triggered execution use this.
+ * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
+ * (for command-triggered mode this is the per-line augmented task).
+ */
+async function invokeAgentWithRetry(ctx, invokeTask) {
+    let retryPrompt;
+    // eslint-disable-next-line no-constant-condition
+    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 },
+            echoStdout: true,
+            resolveOnFailure: true,
+            stdin,
+        });
+        const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
+        const reportFiles = parseReportFiles(result.output);
+        const requiredPermissions = parsePermissions(result.output);
+        // Permission retry
+        if (outcome === "failed" && requiredPermissions.length > 0) {
+            const response = await requestPermission(ctx.nc, ctx.config, ctx.task, ctx.taskDir, requiredPermissions, ctx.useHttp);
+            await publishPermissionResolved(ctx.nc, ctx.config, ctx.taskId, response, ctx.useHttp);
+            if (response === "aborted") {
+                return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
+            }
+            const newPerms = requiredPermissions.filter((rp) => !ctx.task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
+                && !ctx.transientPermissions.some((ep) => ep.name === rp.name));
+            if (response === "granted_all") {
+                ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
+                invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
+                writeTaskFile(ctx.taskDir, ctx.task);
+            }
+            else {
+                ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
+            }
+            retryPrompt = "Permissions granted, please continue.";
+            continue;
+        }
+        // Input retry
+        const inputRequests = parseInputRequests(result.output);
+        if (outcome === "failed" && inputRequests.length > 0) {
+            const response = await requestUserInput(ctx.nc, ctx.config, ctx.task, ctx.taskDir, inputRequests, ctx.useHttp);
+            await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided", ctx.useHttp);
+            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 };
+    }
+}
+/**
+ * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
+ * respect that instead of overwriting with the process's own outcome.
+ */
+function resolveOutcome(taskDir, outcome) {
+    const current = readTaskStatus(taskDir);
+    if (current?.running_state === "aborted")
+        return "aborted";
+    return outcome;
+}
 /**
  * Execute a task by ID.
  */
@@ -42,24 +111,12 @@ export async function runCommand(taskId) {
             await nc.drain();
         }
     };
-    // Handle signals
-    const onSignal = async () => {
-        console.log("Received signal, cleaning up...");
-        const endTime = Date.now();
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "abort", startTime, endTime, "", [], []);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, "abort", useHttp, taskName);
-        await cleanup();
-        process.exit(1);
-    };
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
     try {
         if (useNats) {
             nc = await connectNats(config);
         }
         // Mark as started immediately
-        await publishTaskEvent(nc, config, taskDir, taskId, "start", useHttp, taskName);
+        await publishTaskEvent(nc, config, taskDir, taskId, "started", useHttp, taskName);
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(nc, config, task, taskDir, useHttp);
@@ -68,110 +125,194 @@ export async function runCommand(taskId) {
             if (!confirmed) {
                 console.log("Task aborted by user.");
                 const endTime = Date.now();
-                const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "abort", startTime, endTime, "", [], []);
+                const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
                 appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-                await publishTaskEvent(nc, config, taskDir, taskId, "abort", useHttp, taskName);
+                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", useHttp, taskName);
                 await cleanup();
                 return;
             }
             console.log("Task confirmed by user.");
         }
-        // Execution loop: retry on permission failure if user grants
+        // Shared invocation context
         const guiEnv = getPlatform().getGuiEnv();
         const agent = getAgent(task.frontmatter.agent);
-        let lastOutput = "";
-        let lastOutcome = "fail";
-        let lastReportFiles = [];
-        let lastRequiredPermissions = [];
-        let lastEndTime = Date.now();
-        let retryPrompt;
-        let transientPermissions = [];
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const { command, args } = agent.getTaskRunCommandLine(task, retryPrompt, transientPermissions);
-            const result = await spawnCommand(command, args, {
-                cwd: taskDir,
-                env: {
-                    ...guiEnv,
-                    PALMIER_TASK_ID: task.frontmatter.id,
-                },
-                echoStdout: true,
-                forwardSignals: true,
-                resolveOnFailure: true,
-            });
-            lastOutput = result.output;
-            lastEndTime = Date.now();
-            lastOutcome = result.exitCode !== 0 ? "fail" : parseTaskOutcome(lastOutput);
-            lastReportFiles = parseReportFiles(lastOutput);
-            lastRequiredPermissions = parsePermissions(lastOutput);
-            // If failed with permission requirements, ask user to grant
-            if (lastOutcome === "fail" && lastRequiredPermissions.length > 0) {
-                const response = await requestPermission(nc, config, task, taskDir, lastRequiredPermissions, useHttp);
-                await publishPermissionResolved(nc, config, taskId, response, useHttp);
-                if (response === "aborted") {
-                    console.log("Permission request aborted by user.");
-                    break;
-                }
-                const newPerms = lastRequiredPermissions.filter((rp) => !task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
-                    && !transientPermissions.some((ep) => ep.name === rp.name));
-                if (response === "granted_all") {
-                    // Persist permissions to task frontmatter for all future runs
-                    task.frontmatter.permissions = [...(task.frontmatter.permissions ?? []), ...newPerms];
-                    writeTaskFile(taskDir, task);
-                }
-                else {
-                    // "granted" — allow for this run only
-                    transientPermissions = [...transientPermissions, ...newPerms];
-                }
-                console.log(`Permissions granted, retrying task ${taskId}...`);
-                retryPrompt = "Permissions granted, please continue.";
-                continue;
+        const ctx = {
+            agent, task, taskDir, guiEnv, nc, config, taskId, useHttp,
+            transientPermissions: [],
+        };
+        if (task.frontmatter.command) {
+            // Command-triggered mode
+            const result = await runCommandTriggeredMode(ctx);
+            const outcome = resolveOutcome(taskDir, result.outcome);
+            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, useHttp, taskName);
+            console.log(`Task ${taskId} completed (command-triggered).`);
+        }
+        else {
+            // Standard execution
+            const result = await invokeAgentWithRetry(ctx, task);
+            const outcome = resolveOutcome(taskDir, result.outcome);
+            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
+            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, useHttp, taskName);
+            if (result.reportFiles.length > 0) {
+                await publishHostEvent(nc, config, taskId, {
+                    event_type: "report-generated",
+                    name: taskName,
+                    report_files: result.reportFiles,
+                    running_state: outcome,
+                }, useHttp);
             }
-            // Normal completion (success or non-permission failure)
-            break;
+            console.log(`Task ${taskId} completed.`);
         }
-        // Write result and history once after the loop
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, lastOutcome, startTime, lastEndTime, lastOutput, lastReportFiles, lastRequiredPermissions);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, lastOutcome, useHttp, taskName);
-        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);
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "fail", startTime, endTime, errorMsg, [], []);
+        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
         appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, "fail", useHttp, taskName);
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, useHttp, taskName);
         process.exitCode = 1;
     }
     finally {
         await cleanup();
     }
 }
-const sc = StringCodec();
+const MAX_QUEUE_SIZE = 100;
+const MAX_LOG_ENTRIES = 1000;
+/** Max input line length (chars). Long emails can take up to 200k chars. */
+const MAX_LINE_LENGTH = 200_000;
 /**
- * Write status.json and notify connected clients via NATS and/or HTTP SSE.
+ * Command-triggered execution mode.
+ *
+ * Spawns a long-running shell command and, for each line of stdout,
+ * invokes the agent CLI with the user's prompt augmented by that line.
+ * Processes lines sequentially with a bounded queue.
  */
-async function publishHostEvent(nc, config, taskId, payload, useHttp) {
-    const subject = `host-event.${config.hostId}.${taskId}`;
-    if (nc) {
-        nc.publish(subject, sc.encode(JSON.stringify(payload)));
-        console.log(`[nats] ${subject} →`, payload);
+async function runCommandTriggeredMode(ctx) {
+    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 },
+    });
+    // Stats
+    let linesProcessed = 0;
+    let invocationsSucceeded = 0;
+    let invocationsFailed = 0;
+    // Bounded queue for incoming lines
+    const lineQueue = [];
+    let processing = false;
+    let commandExited = false;
+    let resolveWhenDone;
+    // Rolling log of per-line agent outputs
+    const logPath = path.join(ctx.taskDir, "command-output.log");
+    function appendLog(line, agentOutput, outcome) {
+        const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
+        fs.appendFileSync(logPath, entry, "utf-8");
+        // Trim log if too large (keep last MAX_LOG_ENTRIES entries)
+        try {
+            const content = fs.readFileSync(logPath, "utf-8");
+            const entries = content.split("\n---\n").filter(Boolean);
+            if (entries.length > MAX_LOG_ENTRIES) {
+                const trimmed = entries.slice(-MAX_LOG_ENTRIES).join("\n---\n") + "\n---\n";
+                fs.writeFileSync(logPath, trimmed, "utf-8");
+            }
+        }
+        catch { /* ignore trim errors */ }
+    }
+    async function processLine(line) {
+        linesProcessed++;
+        if (line.length > MAX_LINE_LENGTH) {
+            console.warn(`[command-triggered] Skipping line #${linesProcessed}: ${line.length} chars exceeds limit`);
+            invocationsFailed++;
+            appendLog(line.slice(0, 200) + "...(truncated)", "", "skipped");
+            return;
+        }
+        console.log(`[command-triggered] Processing line #${linesProcessed}: ${line}`);
+        const perLinePrompt = `${ctx.task.frontmatter.user_prompt}\n\nProcess this input:\n${line}`;
+        const perLineTask = {
+            frontmatter: { ...ctx.task.frontmatter, user_prompt: perLinePrompt },
+            body: "",
+        };
+        const result = await invokeAgentWithRetry(ctx, perLineTask);
+        if (result.outcome === "finished") {
+            invocationsSucceeded++;
+        }
+        else {
+            invocationsFailed++;
+        }
+        appendLog(line, result.output, result.outcome);
     }
-    if (useHttp && config.directPort) {
+    async function drainQueue() {
+        if (processing)
+            return;
+        processing = true;
         try {
-            await fetch(`http://localhost:${config.directPort}/internal/event`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ task_id: taskId, ...payload }),
-            });
-            console.log(`[http] host-event: ${taskId} →`, payload);
+            while (lineQueue.length > 0) {
+                const line = lineQueue.shift();
+                await processLine(line);
+            }
+        }
+        finally {
+            processing = false;
+            if (commandExited && lineQueue.length === 0 && resolveWhenDone) {
+                resolveWhenDone();
+            }
         }
-        catch (err) {
-            console.error(`[http] Failed to push event:`, err);
+    }
+    // Read stdout line by line
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+        if (!line.trim())
+            return; // skip empty lines
+        if (lineQueue.length >= MAX_QUEUE_SIZE) {
+            console.warn(`[command-triggered] Queue full, dropping oldest line.`);
+            lineQueue.shift();
         }
+        lineQueue.push(line);
+        drainQueue().catch((err) => {
+            console.error(`[command-triggered] Error processing line:`, err);
+            invocationsFailed++;
+        });
+    });
+    // Log stderr
+    child.stderr?.on("data", (d) => process.stderr.write(d));
+    // Wait for command to exit
+    const exitCode = await new Promise((resolve) => {
+        child.on("close", (code) => {
+            commandExited = true;
+            rl.close();
+            resolve(code);
+        });
+        child.on("error", (err) => {
+            console.error(`[command-triggered] Command error:`, err);
+            commandExited = true;
+            rl.close();
+            resolve(1);
+        });
+    });
+    // Wait for any remaining queued lines to finish processing
+    if (lineQueue.length > 0 || processing) {
+        await new Promise((resolve) => {
+            resolveWhenDone = resolve;
+            drainQueue();
+        });
     }
+    const endTime = Date.now();
+    const summary = [
+        `Command: ${commandStr}`,
+        `Exit code: ${exitCode}`,
+        `Lines processed: ${linesProcessed}`,
+        `Agent invocations succeeded: ${invocationsSucceeded}`,
+        `Agent invocations failed: ${invocationsFailed}`,
+    ].join("\n");
+    // Command-triggered tasks run until the command exits — any exit is a normal finish.
+    const outcome = "finished";
+    return { outcome, endTime, output: summary };
 }
 async function publishTaskEvent(nc, config, taskDir, taskId, eventType, useHttp, taskName) {
     writeTaskStatus(taskDir, {
@@ -207,12 +348,12 @@ async function requestPermission(nc, config, task, taskDir, requiredPermissions,
     return new Promise((resolve) => {
         const watcher = fs.watch(statusPath, () => {
             const status = readTaskStatus(taskDir);
-            if (!status || status.user_input === undefined)
+            if (!status || !status.user_input?.length)
                 return;
             watcher.close();
-            const response = status.user_input;
+            const response = status.user_input[0];
             writeTaskStatus(taskDir, {
-                running_state: response === "aborted" ? "abort" : "start",
+                running_state: response === "aborted" ? "aborted" : "started",
                 time_stamp: Date.now(),
             });
             resolve(response);
@@ -226,6 +367,42 @@ async function publishPermissionResolved(nc, config, taskId, status, useHttp) {
         status,
     }, useHttp);
 }
+async function requestUserInput(nc, config, task, taskDir, inputDescriptions, useHttp) {
+    const taskId = task.frontmatter.id;
+    const statusPath = path.join(taskDir, "status.json");
+    const currentStatus = readTaskStatus(taskDir);
+    writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
+    await publishHostEvent(nc, config, taskId, {
+        event_type: "input-request",
+        host_id: config.hostId,
+        input_descriptions: inputDescriptions,
+        name: task.frontmatter.name,
+    }, useHttp);
+    return new Promise((resolve) => {
+        const watcher = fs.watch(statusPath, () => {
+            const status = readTaskStatus(taskDir);
+            if (!status || !status.user_input?.length)
+                return;
+            watcher.close();
+            const response = status.user_input;
+            if (response.length === 1 && response[0] === "aborted") {
+                writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
+                resolve("aborted");
+            }
+            else {
+                writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
+                resolve(response);
+            }
+        });
+    });
+}
+async function publishInputResolved(nc, config, taskId, status, useHttp) {
+    await publishHostEvent(nc, config, taskId, {
+        event_type: "input-resolved",
+        host_id: config.hostId,
+        status,
+    }, useHttp);
+}
 async function requestConfirmation(nc, config, task, taskDir, useHttp) {
     const taskId = task.frontmatter.id;
     const statusPath = path.join(taskDir, "status.json");
@@ -241,13 +418,13 @@ async function requestConfirmation(nc, config, task, taskDir, useHttp) {
     return new Promise((resolve) => {
         const watcher = fs.watch(statusPath, () => {
             const status = readTaskStatus(taskDir);
-            if (!status || status.user_input === undefined)
+            if (!status || !status.user_input?.length)
                 return; // still pending
             watcher.close();
-            const confirmed = status.user_input === "confirmed";
+            const confirmed = status.user_input[0] === "confirmed";
             // Clear pending_confirmation/user_input and update running_state
             writeTaskStatus(taskDir, {
-                running_state: confirmed ? "start" : "abort",
+                running_state: confirmed ? "started" : "aborted",
                 time_stamp: Date.now(),
             });
             resolve(confirmed);
@@ -289,16 +466,31 @@ function parsePermissions(output) {
     }
     return perms;
 }
+/**
+ * Extract user input requests from agent output.
+ * Looks for lines matching: [PALMIER_INPUT] <description>
+ */
+function parseInputRequests(output) {
+    const regex = new RegExp(`^\\${TASK_INPUT_PREFIX}\\s+(.+)$`, "gm");
+    const inputs = [];
+    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 "finish" if no marker is found.
+ * Falls back to "finished" if no marker is found.
  */
 function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
     if (lastChunk.includes(TASK_FAILURE_MARKER))
-        return "fail";
+        return "failed";
     if (lastChunk.includes(TASK_SUCCESS_MARKER))
-        return "finish";
-    return "finish";
+        return "finished";
+    return "finished";
 }
 //# sourceMappingURL=run.js.map

package/dist/commands/serve.js

@@ -1,26 +1,105 @@
+import * as fs from "fs";
+import * as path from "path";
 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 { startHttpTransport } from "../transports/http-transport.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
+import { publishHostEvent } from "../events.js";
+import { getPlatform } from "../platform/index.js";
+const POLL_INTERVAL_MS = 30_000;
+/**
+ * Mark a stuck task as failed: update status.json, write RESULT, append history,
+ * and broadcast the failure event.
+ */
+async function markTaskFailed(config, nc, useHttp, taskId, reason) {
+    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${reason}`;
+    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    const payload = { event_type: "running-state", running_state: "failed", name: taskName };
+    await publishHostEvent(nc, config, taskId, payload, useHttp);
+}
+/**
+ * Scan all tasks for any stuck in "start" state whose process is no longer alive.
+ * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ */
+async function checkStaleTasks(config, nc, useHttp) {
+    const tasksJsonl = path.join(config.projectRoot, "tasks.jsonl");
+    if (!fs.existsSync(tasksJsonl))
+        return;
+    const platform = getPlatform();
+    const lines = fs.readFileSync(tasksJsonl, "utf-8").split("\n").filter(Boolean);
+    for (const line of lines) {
+        let taskId;
+        try {
+            taskId = JSON.parse(line).task_id;
+        }
+        catch {
+            continue;
+        }
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        const status = readTaskStatus(taskDir);
+        if (!status || status.running_state !== "started")
+            continue;
+        // Ask the system scheduler if the task is still running
+        if (platform.isTaskRunning(taskId))
+            continue;
+        await markTaskFailed(config, nc, useHttp, taskId, "Task process exited unexpectedly");
+    }
+}
 /**
  * Start the persistent RPC handler using the configured transport(s).
  */
 export async function serveCommand() {
     const config = loadConfig();
-    const handleRpc = createRpcHandler(config);
     const mode = config.mode ?? "nats";
     console.log(`Starting in ${mode} mode...`);
+    // Connect NATS once, share between RPC handler, transport, and monitor
+    const useNats = mode === "nats" || mode === "auto";
+    const useHttp = mode === "lan" || mode === "auto";
+    const nc = useNats ? await connectNats(config) : undefined;
+    // Reconcile any tasks stuck from before daemon started
+    await checkStaleTasks(config, nc, useHttp);
+    // Poll for crashed tasks every 30 seconds
+    setInterval(() => {
+        checkStaleTasks(config, nc, useHttp).catch((err) => {
+            console.error("[monitor] Error checking stale tasks:", err);
+        });
+    }, POLL_INTERVAL_MS);
+    const handleRpc = createRpcHandler(config, nc);
     if (mode === "auto") {
         await Promise.all([
-            startNatsTransport(config, handleRpc),
-            startHttpTransport(config, handleRpc),
+            startNatsTransport(config, handleRpc, nc),
+            startHttpTransport(config, handleRpc).catch((err) => {
+                if (err.code === "EADDRINUSE") {
+                    console.warn(`[http] Port already in use, skipping HTTP transport.`);
+                }
+                else {
+                    throw err;
+                }
+            }),
         ]);
     }
     else if (mode === "lan") {
         await startHttpTransport(config, handleRpc);
     }
     else {
-        await startNatsTransport(config, handleRpc);
+        await startNatsTransport(config, handleRpc, nc);
     }
 }
 //# sourceMappingURL=serve.js.map

package/dist/commands/task-cleanup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Post-exit cleanup for a task process.
+ *
+ * Called by the platform hook (ExecStopPost on Linux, wrapper script on Windows)
+ * after the main `palmier run <taskId>` process exits.
+ *
+ * - If status.json shows "finish" or "fail", the process handled its own cleanup — no-op.
+ * - If status.json shows "abort", the RPC handler already wrote status and broadcast —
+ *   just write the RESULT file and append history.
+ * - If status.json shows "start", the process died unexpectedly — write "fail" status,
+ *   RESULT file, append history, and broadcast event.
+ */
+export declare function taskCleanupCommand(taskId: string): Promise<void>;
+//# sourceMappingURL=task-cleanup.d.ts.map