palmier 0.6.7 → 0.6.9

package/src/mcp-tools.ts

@@ -19,14 +19,18 @@ export interface ToolContext {
 
 export interface ToolDefinition {
   name: string;
-  description: string;
+  /** First line is the summary (used as endpoint header). Remaining lines become bullet points in docs. */
+  description: string[];
   inputSchema: object;
   handler: (args: Record<string, unknown>, ctx: ToolContext) => Promise<unknown>;
 }
 
 const notifyTool: ToolDefinition = {
   name: "notify",
-  description: "Send a push notification to the user's device.",
+  description: [
+    "Send a push notification to the user's device.",
+    'Response: `{"ok": true}` on success.',
+  ],
   inputSchema: {
     type: "object",
     properties: {
@@ -55,7 +59,12 @@ const notifyTool: ToolDefinition = {
 
 const requestInputTool: ToolDefinition = {
   name: "request-input",
-  description: "Request input from the user. The request blocks until the user responds.",
+  description: [
+    "Request input from the user.",
+    "The request blocks until the user responds.",
+    'Response: `{"values": ["answer1", "answer2"]}` on success, or `{"aborted": true}` if the user declines.',
+    "When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment — use this endpoint instead.",
+  ],
   inputSchema: {
     type: "object",
     properties: {
@@ -87,18 +96,28 @@ const requestInputTool: ToolDefinition = {
     const response = await pendingPromise;
 
     if (response.length === 1 && response[0] === "aborted") {
-      await ctx.publishEvent("_input", { event_type: "input-resolved", host_id: ctx.config.hostId, session_id: ctx.sessionId, status: "aborted" });
+      await ctx.publishEvent("_input", {
+        event_type: "input-resolved", host_id: ctx.config.hostId,
+        session_id: ctx.sessionId, status: "aborted",
+      });
       return { aborted: true };
     }
 
-    await ctx.publishEvent("_input", { event_type: "input-resolved", host_id: ctx.config.hostId, session_id: ctx.sessionId, status: "provided" });
+    await ctx.publishEvent("_input", {
+      event_type: "input-resolved", host_id: ctx.config.hostId,
+      session_id: ctx.sessionId, status: "provided",
+    });
     return { values: response };
   },
 };
 
 const requestConfirmationTool: ToolDefinition = {
   name: "request-confirmation",
-  description: "Request confirmation from the user. The request blocks until the user confirms or aborts.",
+  description: [
+    "Request confirmation from the user.",
+    "The request blocks until the user confirms or aborts.",
+    'Response: `{"confirmed": true}` or `{"confirmed": false}`.',
+  ],
   inputSchema: {
     type: "object",
     properties: {
@@ -136,7 +155,12 @@ const requestConfirmationTool: ToolDefinition = {
 
 const deviceGeolocationTool: ToolDefinition = {
   name: "device-geolocation",
-  description: "Get the GPS location of the user's mobile device. Blocks until the device responds (up to 30 seconds).",
+  description: [
+    "Get the GPS location of the user's mobile device.",
+    "When you need the user's real-time location, use this endpoint.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"latitude": ..., "longitude": ..., "accuracy": ..., "timestamp": ...}` on success, or `{"error": "..."}` on failure.',
+  ],
   inputSchema: {
     type: "object",
     properties: {},
@@ -180,3 +204,50 @@ const deviceGeolocationTool: ToolDefinition = {
 
 export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
+
+/**
+ * Generate the HTTP Endpoints markdown section for agent-instructions.md from the tool registry.
+ */
+export function generateEndpointDocs(port: number, taskId: string, tools: ToolDefinition[] = agentTools): string {
+  const baseUrl = `http://localhost:${port}`;
+  const lines: string[] = [
+    `The following HTTP endpoints are available during task execution. Use curl to call them.`,
+    "",
+  ];
+
+  for (const tool of tools) {
+    const schema = tool.inputSchema as { properties?: Record<string, { type?: string; description?: string; items?: { type?: string } }>; required?: string[] };
+    const props = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+
+    // Build example JSON (body only, no taskId)
+    const example: Record<string, unknown> = {};
+    for (const [key, prop] of Object.entries(props)) {
+      if (prop.type === "array") example[key] = ["..."];
+      else example[key] = "...";
+    }
+
+    const queryUrl = `${baseUrl}/${tool.name}?taskId=${taskId}`;
+    const [header, ...details] = tool.description;
+
+    lines.push(`**\`POST ${queryUrl}\`** — ${header}`);
+    if (Object.keys(example).length > 0) {
+      lines.push("```json");
+      lines.push(JSON.stringify(example));
+      lines.push("```");
+    }
+    for (const [key, prop] of Object.entries(props)) {
+      const req = required.has(key) ? "required" : "optional";
+      let typeStr = prop.type ?? "unknown";
+      if (prop.type === "array" && prop.items?.type) typeStr = `${prop.items.type} array`;
+      lines.push(`- \`${key}\` (${req}, ${typeStr}): ${prop.description ?? ""}`);
+    }
+    for (const detail of details) {
+      lines.push(`- ${detail}`);
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}

package/src/rpc-handler.ts

@@ -1,9 +1,7 @@
 import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-import { fileURLToPath } from "url";
 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";
@@ -18,13 +16,6 @@ import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const PLAN_GENERATION_PROMPT = fs.readFileSync(
-  path.join(__dirname, "commands", "plan-generation.md"),
-  "utf-8",
-);
-
 /**
  * Parse RESULT frontmatter and conversation messages.
  */
@@ -115,40 +106,30 @@ function parseAttr(attrs: string, name: string): string | undefined {
 }
 
 /**
- * Run plan generation for a task prompt using the given agent.
- * Returns the generated plan body and task name.
+ * Generate a concise task name from a user prompt using the given agent.
+ * Falls back to the raw prompt on failure.
  */
-async function generatePlan(
+async function generateName(
   projectRoot: string,
   userPrompt: string,
   agentName: string,
-): Promise<{ name: string; body: string }> {
-  const fullPrompt = PLAN_GENERATION_PROMPT + userPrompt;
-  const planAgent = getAgent(agentName);
-  const { command, args, stdin, env: agentEnv } = planAgent.getPlanGenerationCommandLine(fullPrompt);
-  console.log(`[generatePlan] Running: ${command} ${args.join(" ")}`);
-
-  const { output } = await spawnCommand(command, args, {
-    cwd: projectRoot,
-    timeout: 120_000,
-    stdin,
-    ...(agentEnv ? { env: agentEnv } : {}),
-  });
-
-  let name = "";
-  const trimmed = output.trim();
-  let body = trimmed;
-  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (fmMatch) {
-    try {
-      const fm = parseYaml(fmMatch[1]) as { task_name?: string };
-      name = fm.task_name ?? "";
-    } catch {
-      // If frontmatter parsing fails, treat entire output as body
-    }
-    body = fmMatch[2].trimStart();
+): Promise<string> {
+  const prompt = `Generate a concise 3-6 word name for this task. Reply with ONLY the name, nothing else.\n\nTask: ${userPrompt}`;
+  const agent = getAgent(agentName);
+  const { command, args, stdin, env: agentEnv } = agent.getPromptCommandLine(prompt);
+
+  try {
+    const { output } = await spawnCommand(command, args, {
+      cwd: projectRoot,
+      timeout: 30_000,
+      stdin,
+      ...(agentEnv ? { env: agentEnv } : {}),
+    });
+    const name = output.trim().replace(/^["']|["']$/g, "").slice(0, 80);
+    return name || userPrompt;
+  } catch {
+    return userPrompt;
   }
-  return { name, body };
 }
 
 /** Active follow-up child processes, keyed by "taskId:runId". */
@@ -164,7 +145,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
     const pending = getPending(task.frontmatter.id);
     return {
       ...task.frontmatter,
-      body: task.body,
       status: status ? {
         ...status,
         ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
@@ -216,25 +196,13 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           command?: string;
         };
 
-        // Only generate a plan for longer prompts that benefit from it
-        let name = "";
-        let body = "";
-        if (params.user_prompt.length <= 50) {
-          name = params.user_prompt;
-        } else {
-          try {
-            const plan = await generatePlan(config.projectRoot, params.user_prompt, params.agent);
-            name = plan.name;
-            body = plan.body;
-          } catch (err: unknown) {
-            const error = err as { stdout?: string; stderr?: string };
-            return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
-          }
-        }
+        const name = params.user_prompt.length <= 50
+          ? params.user_prompt
+          : await generateName(config.projectRoot, params.user_prompt, params.agent);
 
         const id = randomUUID();
         const taskDir = getTaskDir(config.projectRoot, id);
-        const task = {
+        const task: ParsedTask = {
           frontmatter: {
             id,
             name,
@@ -247,7 +215,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             ...(params.foreground_mode ? { foreground_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
-          body,
         };
 
         writeTaskFile(taskDir, task);
@@ -273,10 +240,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const taskDir = getTaskDir(config.projectRoot, params.id);
         const existing = parseTaskFile(taskDir);
 
-        // Detect whether plan needs regeneration
+        // Detect whether name needs regeneration
         const promptChanged = params.user_prompt !== undefined && params.user_prompt !== existing.frontmatter.user_prompt;
         const agentChanged = params.agent !== undefined && params.agent !== existing.frontmatter.agent;
-        const needsRegeneration = promptChanged || agentChanged || !existing.body;
 
         // Merge updates
         if (params.user_prompt !== undefined) existing.frontmatter.user_prompt = params.user_prompt;
@@ -298,19 +264,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           }
         }
 
-        // Regenerate plan if needed (only for longer prompts)
-        if (existing.frontmatter.user_prompt.length <= 50) {
-          existing.frontmatter.name = existing.frontmatter.user_prompt;
-          existing.body = "";
-        } else if (needsRegeneration) {
-          try {
-            const plan = await generatePlan(config.projectRoot, existing.frontmatter.user_prompt, existing.frontmatter.agent);
-            existing.frontmatter.name = plan.name;
-            existing.body = plan.body;
-          } catch (err: unknown) {
-            const error = err as { stdout?: string; stderr?: string };
-            return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
-          }
+        // Regenerate name when prompt or agent changes
+        if (promptChanged || agentChanged) {
+          existing.frontmatter.name = existing.frontmatter.user_prompt.length <= 50
+            ? existing.frontmatter.user_prompt
+            : await generateName(config.projectRoot, existing.frontmatter.user_prompt, existing.frontmatter.agent);
         }
 
         writeTaskFile(taskDir, existing);
@@ -357,7 +315,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             ...(params.foreground_mode ? { foreground_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
-          body: "",
         };
 
         writeTaskFile(taskDir, task);

package/src/spawn-command.ts

@@ -89,8 +89,10 @@ export function spawnCommand(
     const finalArgs = process.platform === "win32"
       ? args.map((a) => a.replace(/[\r\n]+/g, " "))
       : args;
+    const truncate = (s: string, max = 100) => s.length > max ? s.slice(0, max) + "..." : s;
+    const displayArgs = finalArgs.map((arg) => truncate(arg));
 
-    // console.log(`[spawn] ${command} ${finalArgs.join(" ")}`);
+    console.log(`[spawn] ${command} ${displayArgs.join(" ")}`);
 
     const child = crossSpawn(command, finalArgs, {
       cwd: opts.cwd,

package/src/task.ts

@@ -29,7 +29,6 @@ export function parseTaskContent(content: string): ParsedTask {
   }
 
   const frontmatter = parseYaml(match[1]) as TaskFrontmatter;
-  const body = (match[2] || "").trim();
 
   if (!frontmatter.id) {
     throw new Error("TASK.md frontmatter must include at least: id");
@@ -39,7 +38,7 @@ export function parseTaskContent(content: string): ParsedTask {
   frontmatter.agent ??= "claude";
   frontmatter.triggers_enabled ??= true;
 
-  return { frontmatter, body };
+  return { frontmatter };
 }
 
 /**
@@ -50,7 +49,7 @@ export function writeTaskFile(taskDir: string, task: ParsedTask): void {
   fs.mkdirSync(taskDir, { recursive: true });
 
   const yamlStr = stringifyYaml(task.frontmatter).trim();
-  const content = `---\n${yamlStr}\n---\n${task.body}\n`;
+  const content = `---\n${yamlStr}\n---\n`;
 
   const filePath = path.join(taskDir, "TASK.md");
   fs.writeFileSync(filePath, content, "utf-8");

package/src/transports/http-transport.ts

@@ -195,11 +195,9 @@ export async function startHttpTransport(
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       const tool = agentToolMap.get(pathname.slice(1))!;
       try {
-        const body = await readBody(req);
-        const args = body.trim() ? JSON.parse(body) : {};
-        const { taskId } = args as { taskId?: string };
+        const taskId = url.searchParams.get("taskId");
         if (!taskId) {
-          sendJson(res, 400, { error: "taskId is required" });
+          sendJson(res, 400, { error: "taskId query parameter is required" });
           return;
         }
         const taskDir = getTaskDir(config.projectRoot, taskId);
@@ -207,7 +205,8 @@ export async function startHttpTransport(
           sendJson(res, 404, { error: `Task not found: ${taskId}` });
           return;
         }
-        delete args.taskId;
+        const body = await readBody(req);
+        const args = body.trim() ? JSON.parse(body) : {};
         const ctx = makeToolContext(taskId);
         console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${tool.name}`);
         const result = await tool.handler(args, ctx);

package/src/types.ts

@@ -36,7 +36,6 @@ export interface Trigger {
 
 export interface ParsedTask {
   frontmatter: TaskFrontmatter;
-  body: string;
 }
 
 /**

package/test/agent-instructions.test.ts

@@ -3,17 +3,57 @@ import assert from "node:assert/strict";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { generateEndpointDocs, type ToolDefinition } from "../src/mcp-tools.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const templatePath = path.join(__dirname, "..", "src", "agents", "agent-instructions.md");
 const template = fs.readFileSync(templatePath, "utf-8");
 
+/** Mock tools with a known, stable shape for testing */
+const mockTools: ToolDefinition[] = [
+  {
+    name: "mock-action",
+    description: [
+      "Perform a mock action.",
+      'Response: `{"ok": true}` on success.',
+    ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Action title" },
+        detail: { type: "string", description: "Optional detail" },
+      },
+      required: ["title"],
+    },
+    handler: async () => ({ ok: true }),
+  },
+  {
+    name: "mock-query",
+    description: [
+      "Query mock data from the device.",
+      "Blocks until the device responds.",
+      'Response: `{"data": ...}` on success.',
+    ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter tags",
+        },
+      },
+    },
+    handler: async () => ({ data: [] }),
+  },
+];
+
 /** Minimal replica of getAgentInstructions that doesn't need host.json */
-function buildInstructions(taskId: string, skipPermissions?: boolean): string {
+function buildInstructions(taskId: string, opts?: { skipPermissions?: boolean }): string {
   let instructions = template
-    .replace(/\{\{PORT\}\}/g, "9966")
-    .replace(/\{\{TASK_ID\}\}/g, taskId);
-  if (skipPermissions) {
+    .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(9966, taskId, mockTools))
+    .replace(/\{\{TASK_DESCRIPTION\}\}/g, "Test task prompt");
+  if (opts?.skipPermissions) {
     instructions = instructions.replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
   }
   return instructions;
@@ -27,22 +67,110 @@ describe("getAgentInstructions", () => {
   });
 
   it("strips Permissions section when skipPermissions is true", () => {
-    const result = buildInstructions("test-task-id", true);
+    const result = buildInstructions("test-task-id", { skipPermissions: true });
     assert.doesNotMatch(result, /## Permissions/);
     assert.doesNotMatch(result, /PALMIER_PERMISSION/);
   });
 
   it("preserves other sections when Permissions is stripped", () => {
-    const result = buildInstructions("test-task-id", true);
+    const result = buildInstructions("test-task-id", { skipPermissions: true });
     assert.match(result, /## Reporting Output/);
     assert.match(result, /## Completion/);
     assert.match(result, /## HTTP Endpoints/);
   });
 
-  it("replaces template variables", () => {
+  it("replaces all template variables", () => {
+    const result = buildInstructions("my-task-123");
+    assert.doesNotMatch(result, /\{\{ENDPOINT_DOCS\}\}/);
+    assert.doesNotMatch(result, /\{\{TASK_DESCRIPTION\}\}/);
+  });
+
+  it("includes task ID in endpoint examples", () => {
     const result = buildInstructions("my-task-123");
     assert.match(result, /my-task-123/);
-    assert.doesNotMatch(result, /\{\{TASK_ID\}\}/);
-    assert.doesNotMatch(result, /\{\{PORT\}\}/);
+  });
+
+  it("includes port in endpoint URL", () => {
+    const result = buildInstructions("test");
+    assert.match(result, /localhost:9966/);
+  });
+
+  it("includes task description", () => {
+    const result = buildInstructions("test");
+    assert.match(result, /Test task prompt/);
+  });
+
+});
+
+
+describe("generateEndpointDocs", () => {
+  const docs = generateEndpointDocs(9966, "test-id", mockTools);
+
+  it("matches expected full output", () => {
+    const expected = [
+      "The following HTTP endpoints are available during task execution. Use curl to call them.",
+      "",
+      "**`POST http://localhost:9966/mock-action?taskId=test-id`** — Perform a mock action.",
+      "```json",
+      '{"title":"...","detail":"..."}',
+      "```",
+      "- `title` (required, string): Action title",
+      "- `detail` (optional, string): Optional detail",
+      '- Response: `{"ok": true}` on success.',
+      "",
+      "**`POST http://localhost:9966/mock-query?taskId=test-id`** — Query mock data from the device.",
+      "```json",
+      '{"tags":["..."]}',
+      "```",
+      "- `tags` (optional, string array): Filter tags",
+      "- Blocks until the device responds.",
+      '- Response: `{"data": ...}` on success.',
+    ].join("\n");
+    assert.equal(docs, expected);
+  });
+
+  it("generates docs for all provided tools", () => {
+    for (const tool of mockTools) {
+      assert.match(docs, new RegExp(`POST http://localhost:9966/${tool.name}\\?taskId=`), `Missing endpoint for ${tool.name}`);
+    }
+  });
+
+  it("includes taskId parameter for every endpoint", () => {
+    const endpointBlocks = docs.split("**`POST");
+    // First element is the header, skip it
+    for (let i = 1; i < endpointBlocks.length; i++) {
+      assert.match(endpointBlocks[i], /taskId/, `Missing taskId in endpoint block ${i}`);
+    }
+  });
+
+  it("includes port in the header", () => {
+    assert.match(docs, /localhost:9966/);
+  });
+
+  it("includes task ID in query parameters", () => {
+    assert.match(docs, /taskId=test-id/);
+  });
+
+  it("includes response descriptions", () => {
+    for (const tool of mockTools) {
+      if (tool.description.length > 1) {
+        assert.match(docs, /Response:/, `Missing response description for ${tool.name}`);
+      }
+    }
+  });
+
+  it("marks required and optional parameters correctly", () => {
+    assert.match(docs, /\(required, string\)/);
+    // "detail" has no required entry, so it should be optional
+    assert.match(docs, /\(optional, string\)/);
+  });
+
+  it("handles array-type parameters", () => {
+    assert.match(docs, /\(optional, string array\)/);
+    assert.match(docs, /Filter tags/);
+  });
+
+  it("renders multi-line descriptions as bullet points", () => {
+    assert.match(docs, /- Blocks until the device responds\./);
   });
 });

package/test/agent-output-parsing.test.ts

@@ -71,3 +71,4 @@ describe("parsePermissions", () => {
   });
 });
 
+

package/test/task-parsing.test.ts

@@ -19,7 +19,7 @@ This is the task body.`;
     assert.equal(result.frontmatter.id, "abc123");
     assert.equal(result.frontmatter.name, "Test Task");
     assert.equal(result.frontmatter.agent, "claude");
-    assert.equal(result.body, "This is the task body.");
+    assert.equal(result.frontmatter.user_prompt, "Do something");
   });
 
   it("defaults agent to claude when not specified", () => {
@@ -68,7 +68,7 @@ requires_confirmation: false
     assert.throws(() => parseTaskContent("---\nname: test\n---\n"), /must include at least: id/);
   });
 
-  it("handles empty body", () => {
+  it("handles empty body gracefully", () => {
     const content = `---
 id: abc123
 user_prompt: test
@@ -78,6 +78,6 @@ requires_confirmation: false
 ---`;
 
     const result = parseTaskContent(content);
-    assert.equal(result.body, "");
+    assert.equal(result.frontmatter.id, "abc123");
   });
 });

package/dist/commands/plan-generation.md

@@ -1,22 +0,0 @@
-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 Format
-
-Start with a YAML frontmatter block (no code fences), then the plan body:
-
----
-task_name: <concise label, 3-6 words>
----
-
-<plan body>
-
-## Plan Body Guidelines
-
-- 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.
-- Preserve relative time expressions (e.g., "today", "yesterday", "last week") exactly as written — do **not** resolve them to specific dates. The plan may be executed on a different day than it was generated.
-- If the task involves opening a web browser or application, include a final step to close it before finishing.
-
-## Task Description
-

package/src/commands/plan-generation.md

@@ -1,22 +0,0 @@
-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 Format
-
-Start with a YAML frontmatter block (no code fences), then the plan body:
-
----
-task_name: <concise label, 3-6 words>
----
-
-<plan body>
-
-## Plan Body Guidelines
-
-- 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.
-- Preserve relative time expressions (e.g., "today", "yesterday", "last week") exactly as written — do **not** resolve them to specific dates. The plan may be executed on a different day than it was generated.
-- If the task involves opening a web browser or application, include a final step to close it before finishing.
-
-## Task Description
-