palmier 0.4.4 → 0.4.6

package/src/agents/gemini.ts

@@ -1,7 +1,7 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
-import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
+import { getAgentInstructions } from "./shared-prompt.js";
 import { SHELL } from "../platform/index.js";
 
 export class GeminiAgent implements AgentTool {
@@ -12,10 +12,10 @@ export class GeminiAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
-    const fullPrompt = AGENT_INSTRUCTIONS + "\n\n" + prompt;
-    const args = ["--prompt", "-"];
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = followupPrompt ?? (task.body || task.frontmatter.user_prompt);
+    const fullPrompt = getAgentInstructions(task.frontmatter.id) + "\n\n" + prompt;
+    const args = ["--prompt", "--allowed-tools", "web_fetch", "-"];
 
     const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
     if (allPerms.length > 0) {
@@ -25,7 +25,7 @@ export class GeminiAgent implements AgentTool {
       }
     }
 
-    if (retryPrompt) {args.push("--resume");} // continue mode for retries
+    if (followupPrompt) {args.push("--resume");} // continue mode for followups
     return { command: "gemini", args, stdin: fullPrompt };
   }
 

package/src/agents/openclaw.ts

@@ -1,7 +1,7 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
-import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
+import { getAgentInstructions } from "./shared-prompt.js";
 
 export class OpenClawAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
@@ -11,8 +11,8 @@ export class OpenClawAgent implements AgentTool {
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = getAgentInstructions(task.frontmatter.id) + "\n\n" + (followupPrompt ?? (task.body || task.frontmatter.user_prompt));
     // OpenClaw does not support stdin as prompt.
     const args = ["agent", "--local", "--session-id", task.frontmatter.id, "--message", prompt];
 

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/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";
 
@@ -36,23 +35,23 @@ interface InvocationResult {
 }
 
 /**
- * Invoke the agent CLI with a retry loop for permissions and user input.
+ * Invoke the agent CLI with a continuation 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(
+async function invokeAgentWithContinuation(
   ctx: InvocationContext,
   invokeTask: ParsedTask,
 ): Promise<InvocationResult> {
-  let retryPrompt: string | undefined;
+  let followupPrompt: string | undefined;
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
+    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,
@@ -70,10 +69,9 @@ async function invokeAgentWithRetry(
       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);
+    // Permission handling — agent requested permissions
+    if (requiredPermissions.length > 0) {
+      const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
 
       if (response === "aborted") {
         await appendAndNotify(ctx, {
@@ -106,11 +104,14 @@ async function invokeAgentWithRetry(
         ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
       }
 
-      retryPrompt = "Permissions granted, please continue.";
-      continue;
+      // If the agent actually failed, retry with the new permissions
+      if (outcome === "failed") {
+        followupPrompt = "Permissions granted, please continue.";
+        continue;
+      }
     }
 
-    // Normal completion (success or non-retryable failure)
+    // Normal completion (success or terminal failure)
     return { outcome };
   }
 }
@@ -191,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" });
@@ -229,7 +228,7 @@ export async function runCommand(taskId: string): Promise<void> {
         content: task.body || task.frontmatter.user_prompt,
       });
 
-      const result = await invokeAgentWithRetry(ctx, task);
+      const result = await invokeAgentWithContinuation(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
       appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
       await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
@@ -272,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;
@@ -316,7 +315,7 @@ async function runCommandTriggeredMode(
       body: "",
     };
 
-    const result = await invokeAgentWithRetry(ctx, perLineTask);
+    const result = await invokeAgentWithContinuation(ctx, perLineTask);
     if (result.outcome === "finished") {
       invocationsSucceeded++;
     } else {
@@ -405,41 +404,21 @@ 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 params = new URLSearchParams({
+    taskId: task.frontmatter.id,
+    taskName: task.frontmatter.name,
+    permissions: JSON.stringify(requiredPermissions),
   });
-
-  const userInput = await waitForUserInput(taskDir);
-  const response = userInput[0] as "granted" | "granted_all" | "aborted";
+  const res = await fetch(`http://localhost:${port}/request-permission?${params}`);
+  const { response } = await res.json() as { response: "granted" | "granted_all" | "aborted" };
   writeTaskStatus(taskDir, {
     running_state: response === "aborted" ? "aborted" : "started",
     time_stamp: Date.now(),
@@ -447,35 +426,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 params = new URLSearchParams({
+    taskId: task.frontmatter.id,
+    taskName: task.frontmatter.name,
   });
-
-  const userInput = await waitForUserInput(taskDir);
-  const confirmed = userInput[0] === "confirmed";
+  const res = await fetch(`http://localhost:${port}/request-confirmation?${params}`);
+  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";
@@ -157,8 +158,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" };
     }
 
@@ -521,7 +522,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 +578,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": {