palmier 0.4.5 → 0.4.7

package/src/agents/shared-prompt.ts

@@ -1,19 +1,25 @@
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { loadConfig } from "../config.js";
 
 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 = fs.readFileSync(
+const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(
   path.join(__dirname, "agent-instructions.md"),
   "utf-8",
 );
 
+/**
+ * Agent instructions with the serve daemon's HTTP port and task ID baked in.
+ */
+export function getAgentInstructions(taskId: string): string {
+  const port = loadConfig().httpPort ?? 7400;
+  return AGENT_INSTRUCTIONS_TEMPLATE
+    .replace(/\{\{PORT\}\}/g, String(port))
+    .replace(/\{\{TASK_ID\}\}/g, taskId);
+}
+
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
 export const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";

package/src/commands/init.ts

@@ -3,6 +3,7 @@ import { loadConfig, saveConfig } from "../config.js";
 import { detectAgents } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { pairCommand } from "./pair.js";
+import { detectLanIp } from "../transports/http-transport.js";
 import type { HostConfig } from "../types.js";
 
 type AskFn = (q: string) => Promise<string>;
@@ -39,6 +40,36 @@ export async function initCommand(): Promise<void> {
 
     console.log(`  Found: ${green(agents.map((a) => a.label).join(", "))}\n`);
 
+    // LAN mode
+    const lanAnswer = await ask("Enable LAN access (direct HTTP from local network)? (y/N): ");
+    const lanEnabled = lanAnswer.trim().toLowerCase() === "y";
+
+    let httpPort = 7400;
+    const portLabel = lanEnabled ? "HTTP port for local and LAN access" : "HTTP port for local access";
+    const portAnswer = await ask(`${portLabel} (default ${httpPort}): `);
+    const parsed = parseInt(portAnswer.trim(), 10);
+    if (parsed > 0 && parsed < 65536) httpPort = parsed;
+
+    // Display summary and ask for confirmation before making any changes
+    console.log(`\n${bold("Setup summary:")}\n`);
+    console.log(`  ${dim("Task storage:")}   ${bold(process.cwd())}`);
+    console.log(`                  All tasks and execution data will be stored here.\n`);
+    console.log(`  ${dim("Local access:")}   ${cyan(`http://localhost:${httpPort}`)}`);
+    console.log(`                  Always available — no internet required.\n`);
+    if (lanEnabled) {
+      const ip = detectLanIp();
+      console.log(`  ${dim("LAN access:")}     ${cyan(`http://${ip}:${httpPort}`)}`);
+      console.log(`                  Accessible from other devices on your local network. Pairing required.\n`);
+    }
+    console.log(`  ${dim("Agents:")}         ${agents.map((a) => a.label).join(", ")}\n`);
+
+    const confirm = await ask("Proceed? (Y/n): ");
+    if (confirm.trim().toLowerCase() === "n") {
+      console.log("\nSetup cancelled.");
+      rl.close();
+      return;
+    }
+
     // Register with server
     let existingHostId: string | undefined;
     try { existingHostId = loadConfig().hostId; } catch { /* first init */ }
@@ -63,7 +94,7 @@ export async function initCommand(): Promise<void> {
       }
     }
 
-    // Build config
+    // Build and save config
     const config: HostConfig = {
       hostId: registerResponse.hostId,
       projectRoot: process.cwd(),
@@ -71,11 +102,11 @@ export async function initCommand(): Promise<void> {
       natsWsUrl: registerResponse.natsWsUrl,
       natsToken: registerResponse.natsToken,
       agents,
+      httpPort,
+      lanEnabled,
     };
 
     saveConfig(config);
-
-    console.log(`\n${green("Host provisioned")} ID: ${cyan(config.hostId)}`);
     console.log(`Config saved to ${dim("~/.config/palmier/host.json")}`);
 
     getPlatform().installDaemon(config);

package/src/commands/pair.ts

@@ -3,7 +3,6 @@ import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { addSession } from "../session-store.js";
-import { getLanPort } from "../lan-lock.js";
 import type { HostConfig } from "../types.js";
 
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
@@ -26,9 +25,9 @@ function buildPairResponse(config: HostConfig, label?: string) {
 }
 
 /**
- * POST to the running LAN server and long-poll until paired or expired.
+ * POST to the running serve daemon and long-poll until paired or expired.
  */
-function lanPairRegister(port: number, code: string): Promise<boolean> {
+function httpPairRegister(port: number, code: string): Promise<boolean> {
   const body = JSON.stringify({ code, expiryMs: PAIRING_EXPIRY_MS });
 
   return new Promise((resolve) => {
@@ -36,7 +35,7 @@ function lanPairRegister(port: number, code: string): Promise<boolean> {
       {
         hostname: "127.0.0.1",
         port,
-        path: "/internal/pair-register",
+        path: "/pair-register",
         method: "POST",
         headers: { "Content-Type": "application/json" },
         timeout: PAIRING_EXPIRY_MS + 5000,
@@ -63,11 +62,12 @@ function lanPairRegister(port: number, code: string): Promise<boolean> {
 
 /**
  * Generate an OTP code and wait for a PWA client to pair.
- * Listens on NATS always, and also on the LAN server if `palmier lan` is running.
+ * Listens on NATS (server mode) and HTTP (via serve daemon) in parallel.
  */
 export async function pairCommand(): Promise<void> {
   const config = loadConfig();
   const code = generatePairingCode();
+  const httpPort = config.httpPort ?? 7400;
 
   let paired = false;
 
@@ -86,7 +86,7 @@ export async function pairCommand(): Promise<void> {
   console.log("");
   console.log("Code expires in 5 minutes.");
 
-  // NATS pairing (always active)
+  // NATS pairing (server mode)
   const nc = await connectNats(config);
   const sc = StringCodec();
   const subject = `pair.${code}`;
@@ -116,14 +116,11 @@ export async function pairCommand(): Promise<void> {
     }
   })();
 
-  // LAN pairing — if `palmier lan` is running, also register with it
-  const lanPort = getLanPort();
-  if (lanPort) {
-    (async () => {
-      const result = await lanPairRegister(lanPort, code);
-      if (result) onPaired();
-    })();
-  }
+  // HTTP pairing — register with serve daemon's /pair-register endpoint
+  (async () => {
+    const result = await httpPairRegister(httpPort, code);
+    if (result) onPaired();
+  })();
 
   // Wait for pairing or timeout
   const start = Date.now();

package/src/commands/plan-generation.md

@@ -1,24 +1,21 @@
-You are a task planning assistant. Given a task description, produce a Markdown execution plan for an agent. **Do not execute any part of the plan yourself.**
+You are a task planning assistant. Given a task description, produce a Markdown execution plan for an AI agent to follow. Do not execute any part of the plan yourself.
 
-Output a raw YAML frontmatter block (delimited by `---`) followed by the plan body. Do NOT wrap frontmatter in code fences. The first line of output must be `---`.
+## Output Format
+
+Start with a YAML frontmatter block (no code fences), then the plan body:
 
 ---
-task_name: <short name, 3-6 words>
+task_name: <concise label, 3-6 words>
 ---
 
-**Frontmatter:** `task_name` — concise label (e.g., "Clean up temp files", "Backup database daily").
-
-**Plan body:**
-
-### 1. Goal
-What the task accomplishes and the expected end state.
+<plan body>
 
-### 2. Plan
-Numbered sequence of concrete, actionable steps. Include conditional branches where behavior may vary. Each step must be unambiguous.
+## Plan Body Guidelines
 
-### 3. Output Format (if applicable)
-If the task produces formatted output (report, email, etc.), specify structure, sections, tone, and templates.
+- Write a numbered sequence of concrete, actionable steps.
+- If the task produces formatted output (report, email, summary, etc.), specify the structure, sections, and tone.
+- When a step requires user input, simply state what information is needed from the user. Do not specify how to obtain it — the agent has its own tool for requesting user input.
+- Relative times in the task description (e.g., "yesterday", "last week") refer to execution time, not plan generation time.
 
-Relative times in the task description (e.g., "yesterday") are relative to execution time, not plan generation time.
+## Task Description
 
-**Task description:**

package/src/commands/run.ts

@@ -10,7 +10,6 @@ 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 type { AgentTool } from "../agents/agent.js";
 import { publishHostEvent } from "../events.js";
-import { waitForUserInput } from "../user-input.js";
 import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
 import type { NatsConnection } from "nats";
 
@@ -52,7 +51,7 @@ async function invokeAgentWithContinuation(
     const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, followupPrompt, ctx.transientPermissions);
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
-      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
+      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -72,8 +71,7 @@ async function invokeAgentWithContinuation(
 
     // Permission handling — agent requested permissions
     if (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);
+      const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
 
       if (response === "aborted") {
         await appendAndNotify(ctx, {
@@ -174,7 +172,7 @@ export async function runCommand(taskId: string): Promise<void> {
 
   // 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());
+  const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now(), task.frontmatter.agent);
   if (!existingRunId) {
     appendHistory(config.projectRoot, { task_id: taskId, run_id: runId });
   }
@@ -194,9 +192,7 @@ export async function runCommand(taskId: string): Promise<void> {
 
     // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
-      const confirmed = await requestConfirmation(nc, config, task, taskDir);
-      const resolvedStatus = confirmed ? "confirmed" : "aborted";
-      await publishConfirmResolved(nc, config, taskId, resolvedStatus);
+      const confirmed = await requestConfirmation(config, task, taskDir);
       if (!confirmed) {
         console.log("Task aborted by user.");
         appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
@@ -275,7 +271,7 @@ async function runCommandTriggeredMode(
 
   const child = spawnStreamingCommand(commandStr, {
     cwd: getRunDir(ctx.taskDir, ctx.runId),
-    env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
+    env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
   });
 
   let linesProcessed = 0;
@@ -408,41 +404,24 @@ async function publishTaskEvent(
   await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 
-/**
- * Notify clients that a confirmation request has been resolved.
- */
-async function publishConfirmResolved(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  taskId: string,
-  status: "confirmed" | "aborted",
-): Promise<void> {
-  await publishHostEvent(nc, config.hostId, taskId, {
-    event_type: "confirm-resolved",
-    host_id: config.hostId,
-    status,
-  });
-}
 
 async function requestPermission(
-  nc: NatsConnection | undefined,
   config: HostConfig,
   task: ParsedTask,
   taskDir: string,
   requiredPermissions: RequiredPermission[],
 ): Promise<"granted" | "granted_all" | "aborted"> {
-  const currentStatus = readTaskStatus(taskDir)!;
-  writeTaskStatus(taskDir, { ...currentStatus, pending_permission: requiredPermissions });
-
-  await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-    event_type: "permission-request",
-    host_id: config.hostId,
-    required_permissions: requiredPermissions,
-    name: task.frontmatter.name,
+  const port = config.httpPort ?? 7400;
+  const res = await fetch(`http://localhost:${port}/request-permission`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      taskId: task.frontmatter.id,
+      taskName: task.frontmatter.name,
+      permissions: requiredPermissions,
+    }),
   });
-
-  const userInput = await waitForUserInput(taskDir);
-  const response = userInput[0] as "granted" | "granted_all" | "aborted";
+  const { response } = await res.json() as { response: "granted" | "granted_all" | "aborted" };
   writeTaskStatus(taskDir, {
     running_state: response === "aborted" ? "aborted" : "started",
     time_stamp: Date.now(),
@@ -450,35 +429,19 @@ async function requestPermission(
   return response;
 }
 
-async function publishPermissionResolved(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  taskId: string,
-  status: "granted" | "granted_all" | "aborted",
-): Promise<void> {
-  await publishHostEvent(nc, config.hostId, taskId, {
-    event_type: "permission-resolved",
-    host_id: config.hostId,
-    status,
-  });
-}
 
 async function requestConfirmation(
-  nc: NatsConnection | undefined,
   config: HostConfig,
   task: ParsedTask,
   taskDir: string,
 ): Promise<boolean> {
-  const currentStatus = readTaskStatus(taskDir)!;
-  writeTaskStatus(taskDir, { ...currentStatus, pending_confirmation: true });
-
-  await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-    event_type: "confirm-request",
-    host_id: config.hostId,
+  const port = config.httpPort ?? 7400;
+  const res = await fetch(`http://localhost:${port}/request-confirmation`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
   });
-
-  const userInput = await waitForUserInput(taskDir);
-  const confirmed = userInput[0] === "confirmed";
+  const { confirmed } = await res.json() as { confirmed: boolean };
   writeTaskStatus(taskDir, {
     running_state: confirmed ? "started" : "aborted",
     time_stamp: Date.now(),

package/src/commands/serve.ts

@@ -4,6 +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 { startHttpTransport } from "../transports/http-transport.js";
 import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
@@ -78,7 +79,7 @@ async function checkStaleTasks(
 }
 
 /**
- * Start the persistent RPC handler (NATS only).
+ * Start the persistent RPC handler (NATS + HTTP).
  */
 export async function serveCommand(): Promise<void> {
   const config = loadConfig();
@@ -107,5 +108,13 @@ export async function serveCommand(): Promise<void> {
   }, POLL_INTERVAL_MS);
 
   const handleRpc = createRpcHandler(config, nc);
-  await startNatsTransport(config, handleRpc, nc);
+  const httpPort = config.httpPort ?? 7400;
+
+  // Start NATS transport (loops forever, fire-and-forget)
+  if (nc) {
+    startNatsTransport(config, handleRpc, nc);
+  }
+
+  // Start HTTP transport (loops forever)
+  await startHttpTransport(config, handleRpc, httpPort, nc);
 }

package/src/events.ts

@@ -1,13 +1,13 @@
 import { StringCodec, type NatsConnection } from "nats";
-import { getLanPort } from "./lan-lock.js";
+import { loadConfig } from "./config.js";
 
 const sc = StringCodec();
 
 /**
- * Broadcast an event to connected clients via NATS and HTTP SSE (if LAN server is running).
+ * Broadcast an event to connected clients via NATS and HTTP SSE.
  *
  * - NATS: publishes to `host-event.{hostId}.{taskId}`
- * - HTTP: POSTs to the LAN server's `/internal/event` endpoint (auto-detected via lockfile)
+ * - HTTP: POSTs to the serve daemon's `/event` endpoint
  */
 export async function publishHostEvent(
   nc: NatsConnection | undefined,
@@ -22,17 +22,16 @@ export async function publishHostEvent(
     console.log(`[nats] ${subject} →`, payload);
   }
 
-  const lanPort = getLanPort();
-  if (lanPort) {
-    try {
-      await fetch(`http://localhost:${lanPort}/internal/event`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ task_id: taskId, ...payload }),
-      });
-      console.log(`[http] host-event: ${taskId} →`, payload);
-    } catch {
-      // LAN server may have shut down — ignore
-    }
+  const config = loadConfig();
+  const port = config.httpPort ?? 7400;
+  try {
+    await fetch(`http://localhost:${port}/event`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ task_id: taskId, ...payload }),
+    });
+    console.log(`[http] host-event: ${taskId} →`, payload);
+  } catch {
+    // Serve HTTP may not be ready yet — ignore
   }
 }

package/src/index.ts

@@ -9,11 +9,8 @@ import { initCommand } from "./commands/init.js";
 import { infoCommand } from "./commands/info.js";
 import { runCommand } from "./commands/run.js";
 import { serveCommand } from "./commands/serve.js";
-import { notifyCommand } from "./commands/notify.js";
-import { requestInputCommand } from "./commands/request-input.js";
 
 import { pairCommand } from "./commands/pair.js";
-import { lanCommand } from "./commands/lan.js";
 import { restartCommand } from "./commands/restart.js";
 import { sessionsListCommand, sessionsRevokeCommand, sessionsRevokeAllCommand } from "./commands/sessions.js";
 
@@ -62,22 +59,6 @@ program
     await restartCommand();
   });
 
-program
-  .command("notify")
-  .description("Send a push notification to the user")
-  .requiredOption("--title <title>", "Notification title")
-  .requiredOption("--body <body>", "Notification body text")
-  .action(async (opts: { title: string; body: string }) => {
-    await notifyCommand(opts);
-  });
-
-program
-  .command("request-input")
-  .description("Request input from the user (requires PALMIER_TASK_ID env var)")
-  .requiredOption("--description <desc...>", "Input descriptions to show the user")
-  .action(async (opts: { description: string[] }) => {
-    await requestInputCommand(opts);
-  });
 
 program
   .command("pair")
@@ -86,13 +67,6 @@ program
     await pairCommand();
   });
 
-program
-  .command("lan")
-  .description("Start an on-demand LAN server for direct HTTP connections")
-  .option("-p, --port <port>", "Port to listen on", "7400")
-  .action(async (opts: { port: string }) => {
-    await lanCommand({ port: parseInt(opts.port, 10) });
-  });
 
 const sessionsCmd = program
   .command("sessions")

package/src/pending-requests.ts

@@ -0,0 +1,55 @@
+import type { RequiredPermission } from "./types.js";
+
+export interface PendingRequest {
+  type: "confirmation" | "permission" | "input";
+  resolve: (value: string[]) => void;
+  /** Permission list (for 'permission') or input descriptions (for 'input'). */
+  params?: RequiredPermission[] | string[];
+}
+
+const pending = new Map<string, PendingRequest>();
+
+/**
+ * Register a pending request for a task. Returns a Promise that resolves
+ * when `resolvePending` is called with the user's response.
+ * Only one pending request per task at a time.
+ */
+export function registerPending(
+  taskId: string,
+  type: PendingRequest["type"],
+  params?: PendingRequest["params"],
+): Promise<string[]> {
+  if (pending.has(taskId)) {
+    return Promise.reject(new Error(`Task ${taskId} already has a pending request`));
+  }
+
+  return new Promise<string[]>((resolve) => {
+    pending.set(taskId, { type, resolve, params });
+  });
+}
+
+/**
+ * Resolve a pending request with the user's response.
+ * Returns true if a pending request was found and resolved.
+ */
+export function resolvePending(taskId: string, value: string[]): boolean {
+  const entry = pending.get(taskId);
+  if (!entry) return false;
+  pending.delete(taskId);
+  entry.resolve(value);
+  return true;
+}
+
+/**
+ * Get the current pending request for a task (if any).
+ */
+export function getPending(taskId: string): PendingRequest | undefined {
+  return pending.get(taskId);
+}
+
+/**
+ * Remove a pending request without resolving it.
+ */
+export function removePending(taskId: string): void {
+  pending.delete(taskId);
+}

package/src/rpc-handler.ts

@@ -6,6 +6,7 @@ import { spawn, type ChildProcess } from "child_process";
 import { parse as parseYaml } from "yaml";
 import { type NatsConnection } from "nats";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createRunDir, appendRunMessage, getRunDir } from "./task.js";
+import { resolvePending, getPending } from "./pending-requests.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import crossSpawn from "cross-spawn";
@@ -57,6 +58,7 @@ function parseResultFrontmatter(raw: string): Record<string, unknown> {
   return {
     messages,
     task_name: meta.task_name,
+    agent: meta.agent,
     running_state: runningState,
     start_time: startedMsg?.time || undefined,
     end_time: terminalMsg?.time || undefined,
@@ -157,8 +159,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   }
 
   async function handleRpc(request: RpcMessage): Promise<unknown> {
-    // Session token validation: always require a valid session token
-    if (!request.sessionToken || !validateSession(request.sessionToken)) {
+    // Session token validation: skip for trusted localhost requests
+    if (!request.localhost && (!request.sessionToken || !validateSession(request.sessionToken))) {
       return { error: "Unauthorized" };
     }
 
@@ -317,7 +319,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // Do NOT append to tasks.jsonl — this is a one-off run
 
         // Create initial result file so it appears in runs list immediately
-        const runId = createRunDir(taskDir, name, Date.now());
+        const runId = createRunDir(taskDir, name, Date.now(), params.agent);
         appendHistory(config.projectRoot, { task_id: id, run_id: runId });
 
         // Spawn `palmier run <id>` directly as a detached process
@@ -338,7 +340,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           // Create initial result file so it appears in runs list immediately
           const runTaskDir = getTaskDir(config.projectRoot, params.id);
           const runTask = parseTaskFile(runTaskDir);
-          const taskRunId = createRunDir(runTaskDir, runTask.frontmatter.name, Date.now());
+          const taskRunId = createRunDir(runTaskDir, runTask.frontmatter.name, Date.now(), runTask.frontmatter.agent);
           appendHistory(config.projectRoot, { task_id: params.id, run_id: taskRunId });
 
           await getPlatform().startTask(params.id);
@@ -521,7 +523,14 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         if (!status) {
           return { task_id: params.id, error: "No status found" };
         }
-        return { task_id: params.id, ...status };
+        const pending = getPending(params.id);
+        return {
+          task_id: params.id,
+          ...status,
+          ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
+          ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
+          ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
+        };
       }
 
       case "task.result": {
@@ -570,17 +579,15 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
 
       case "task.user_input": {
         const params = request.params as { id: string; value: string[] };
-        const taskDir = getTaskDir(config.projectRoot, params.id);
 
-        const currentStatus = readTaskStatus(taskDir);
-        if (!currentStatus?.pending_confirmation && !currentStatus?.pending_permission?.length && !currentStatus?.pending_input?.length) {
+        const pending = getPending(params.id);
+        if (!pending) {
           return { ok: false, error: "not pending" };
         }
 
-        writeTaskStatus(taskDir, { ...currentStatus, user_input: params.value });
-
+        const resolved = resolvePending(params.id, params.value);
         console.log(`[task.user_input] ${params.id} → ${params.value}`);
-        return { ok: true };
+        return { ok: resolved };
       }
 
       case "taskrun.list": {

package/src/task.ts

@@ -155,11 +155,13 @@ export function createRunDir(
   taskDir: string,
   taskName: string,
   startTime: number,
+  agent?: string,
 ): string {
   const runId = String(startTime);
   const runDir = path.join(taskDir, runId);
   fs.mkdirSync(runDir, { recursive: true });
-  const content = `---\ntask_name: ${taskName}\n---\n\n`;
+  const agentLine = agent ? `\nagent: ${agent}` : "";
+  const content = `---\ntask_name: ${taskName}${agentLine}\n---\n\n`;
   fs.writeFileSync(path.join(runDir, "TASKRUN.md"), content, "utf-8");
   return runId;
 }