palmier 0.6.8 → 0.7.0

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,39 +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);
-
-  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". */
@@ -163,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 } : {}),
@@ -215,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,
@@ -246,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);
@@ -272,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;
@@ -297,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);
@@ -356,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/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

@@ -6,9 +6,10 @@ import { validateClient, addClient } from "../client-store.js";
 import { registerPending } from "../pending-requests.js";
 import * as fs from "node:fs";
 import type { HostConfig, RpcMessage, RequiredPermission } from "../types.js";
-import { agentToolMap, ToolError, type ToolContext } from "../mcp-tools.js";
-import { handleMcpRequest, getAgentName } from "../mcp-handler.js";
+import { agentToolMap, agentResources, ToolError, type ToolContext } from "../mcp-tools.js";
+import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
 import { getTaskDir } from "../task.js";
+import { onNotificationsChanged } from "../notification-store.js";
 
 // ── Bundled PWA asset serving ───────────────────────────────────────────
 
@@ -102,9 +103,28 @@ export async function startHttpTransport(
   onReady?: () => void,
 ): Promise<void> {
   const sseClients = new Set<SseClient>();
+  const mcpStreams = new Map<string, http.ServerResponse>();
   const lanEnabled = config.lanEnabled ?? false;
   const bindAddress = lanEnabled ? "0.0.0.0" : "127.0.0.1";
 
+  /** Push notifications/resources/updated to all MCP clients subscribed to the given URI. */
+  function broadcastResourceUpdated(uri: string) {
+    const subs = getResourceSubscriptions();
+    for (const [sessionId, uris] of subs) {
+      if (!uris.has(uri)) continue;
+      const stream = mcpStreams.get(sessionId);
+      if (!stream) continue;
+      stream.write(`data: ${JSON.stringify({
+        jsonrpc: "2.0",
+        method: "notifications/resources/updated",
+        params: { uri },
+      })}\n\n`);
+    }
+  }
+
+  // Wire up resource change listeners
+  onNotificationsChanged(() => broadcastResourceUpdated("notifications://device"));
+
   // If a pairing code is provided, pre-register it
   if (pairingCode) {
     const EXPIRY_MS = 24 * 60 * 60 * 1000;
@@ -182,7 +202,24 @@ export async function startHttpTransport(
         if (result.sessionId) {
           res.setHeader("Mcp-Session-Id", result.sessionId);
         }
-        sendJson(res, 200, result.body);
+        if (result.stream && sessionId) {
+          // Keep response open as SSE stream for server-initiated notifications
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+          });
+          res.write(`data: ${JSON.stringify(result.body)}\n\n`);
+          mcpStreams.set(sessionId, res);
+          const heartbeat = setInterval(() => { res.write(":heartbeat\n\n"); }, 15_000);
+          req.on("close", () => {
+            clearInterval(heartbeat);
+            mcpStreams.delete(sessionId);
+            getResourceSubscriptions().delete(sessionId);
+          });
+        } else {
+          sendJson(res, 200, result.body);
+        }
       } catch (err) {
         sendJson(res, 500, { error: String(err) });
       }
@@ -220,6 +257,15 @@ export async function startHttpTransport(
       return;
     }
 
+    // ── Auto-generated REST endpoints from MCP resource registry ────
+
+    const matchedResource = req.method === "GET" && agentResources.find((r) => r.restPath === pathname);
+    if (matchedResource) {
+      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
+      sendJson(res, 200, matchedResource.read());
+      return;
+    }
+
     // ── Localhost-only endpoints (no auth) ─────────────────────────────
 
     if (req.method === "POST" && pathname === "/event") {

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,18 +3,72 @@ import assert from "node:assert/strict";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { generateEndpointDocs, agentTools } from "../src/mcp-tools.js";
+import { generateEndpointDocs, type ToolDefinition, type ResourceDefinition } 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: [] }),
+  },
+];
+
+/** Mock resources with a known, stable shape for testing */
+const mockResources: ResourceDefinition[] = [
+  {
+    uri: "mock://data",
+    name: "Mock Data",
+    description: [
+      "Get mock data from the device.",
+      "Response: JSON array of data objects.",
+    ],
+    mimeType: "application/json",
+    restPath: "/mock-data",
+    read: () => [],
+  },
+];
+
 /** 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(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(9966, taskId))
+    .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(9966, taskId, mockTools, mockResources))
     .replace(/\{\{TASK_DESCRIPTION\}\}/g, "Test task prompt");
-  if (skipPermissions) {
+  if (opts?.skipPermissions) {
     instructions = instructions.replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
   }
   return instructions;
@@ -28,13 +82,13 @@ 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/);
@@ -60,22 +114,41 @@ describe("getAgentInstructions", () => {
     const result = buildInstructions("test");
     assert.match(result, /Test task prompt/);
   });
-});
 
-describe("full agent instruction snapshot", () => {
-  it("matches the expected full text exactly", () => {
-    const result = buildInstructions("test-task-id").replace(/\r\n/g, "\n").trimEnd();
-    const snapshotPath = path.join(__dirname, "fixtures", "agent-instructions-snapshot.md");
-    const expected = fs.readFileSync(snapshotPath, "utf-8").replace(/\r\n/g, "\n").trimEnd();
-    assert.equal(result, expected);
-  });
 });
 
+
 describe("generateEndpointDocs", () => {
-  const docs = generateEndpointDocs(9966, "test-id");
+  const docs = generateEndpointDocs(9966, "test-id", mockTools, mockResources);
+
+  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.',
+      "",
+      "**`GET http://localhost:9966/mock-data`** — Get mock data from the device.",
+      "- Response: JSON array of data objects.",
+    ].join("\n");
+    assert.equal(docs, expected);
+  });
 
-  it("generates docs for all MCP tools", () => {
-    for (const tool of agentTools) {
+  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}`);
     }
   });
@@ -97,8 +170,8 @@ describe("generateEndpointDocs", () => {
   });
 
   it("includes response descriptions", () => {
-    for (const tool of agentTools) {
-      if (tool.responseDescription) {
+    for (const tool of mockTools) {
+      if (tool.description.length > 1) {
         assert.match(docs, /Response:/, `Missing response description for ${tool.name}`);
       }
     }
@@ -106,6 +179,31 @@ describe("generateEndpointDocs", () => {
 
   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\./);
+  });
+
+  it("generates GET endpoints for all provided resources", () => {
+    for (const resource of mockResources) {
+      assert.match(docs, new RegExp(`GET http://localhost:9966${resource.restPath}`), `Missing endpoint for ${resource.uri}`);
+    }
+  });
+
+  it("includes resource description as bullet points", () => {
+    assert.match(docs, /- Response: JSON array of data objects\./);
+  });
+
+  it("generates no resource endpoints when resources array is empty", () => {
+    const docsNoResources = generateEndpointDocs(9966, "test-id", mockTools, []);
+    assert.doesNotMatch(docsNoResources, /GET http/);
+  });
 });

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

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

package/test/notification-store.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+// Re-import fresh module state for each test file run
+// Since the store is module-level state, we test the exported functions directly
+import { addNotification, getNotifications, onNotificationsChanged, type DeviceNotification } from "../src/notification-store.js";
+
+function makeNotification(id: string, overrides?: Partial<DeviceNotification>): DeviceNotification {
+  return {
+    id,
+    packageName: "com.example.app",
+    appName: "Example",
+    title: `Title ${id}`,
+    text: `Text ${id}`,
+    timestamp: Date.now(),
+    receivedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+describe("notification-store", () => {
+  it("stores and retrieves notifications", () => {
+    const before = getNotifications().length;
+    addNotification(makeNotification("test-1"));
+    const after = getNotifications();
+    assert.equal(after.length, before + 1);
+    assert.equal(after[after.length - 1].id, "test-1");
+  });
+
+  it("returns a defensive copy", () => {
+    const a = getNotifications();
+    const b = getNotifications();
+    assert.notStrictEqual(a, b);
+  });
+
+  it("evicts oldest when exceeding max", () => {
+    const before = getNotifications().length;
+    // Add enough to exceed 50
+    for (let i = 0; i < 60; i++) {
+      addNotification(makeNotification(`evict-${i}`));
+    }
+    const result = getNotifications();
+    assert.ok(result.length <= 50, `Expected <= 50, got ${result.length}`);
+  });
+
+  it("notifies listeners on add", () => {
+    let called = 0;
+    const unsub = onNotificationsChanged(() => { called++; });
+    addNotification(makeNotification("listener-1"));
+    assert.equal(called, 1);
+    addNotification(makeNotification("listener-2"));
+    assert.equal(called, 2);
+    unsub();
+    addNotification(makeNotification("listener-3"));
+    assert.equal(called, 2); // no longer called after unsubscribe
+  });
+});

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
-

package/test/fixtures/agent-instructions-snapshot.md

@@ -1,58 +0,0 @@
-You are an AI agent executing a task on behalf of the user. Follow these instructions carefully.
-
-## Reporting Output
-
-If you generate report or output files, print each file path on its own line using this exact format:
-[PALMIER_REPORT] <filename>
-
-## Completion
-
-When you are done, output exactly one of these markers as the very last line (no other text on the same line):
-[PALMIER_TASK_SUCCESS]
-[PALMIER_TASK_FAILURE]
-
-## Permissions
-
-Whenever a tool you are trying to use is denied or you lack the required permissions, print each required permission on its own line using this exact format:
-[PALMIER_PERMISSION] <tool_name> | <description>
-
-## HTTP Endpoints
-
-The following HTTP endpoints are available during task execution. Use curl to call them.
-
-**`POST http://localhost:9966/notify?taskId=test-task-id`** — Send a push notification to the user's device.
-```json
-{"title":"...","body":"..."}
-```
-- `title` (required, string): Notification title
-- `body` (required, string): Notification body
-- Response: `{"ok": true}` on success.
-
-**`POST http://localhost:9966/request-input?taskId=test-task-id`** — Request input from the user.
-```json
-{"description":"...","questions":["..."]}
-```
-- `description` (optional, string): Context or heading for the input request
-- `questions` (required, string array): Questions to present to 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.
-
-**`POST http://localhost:9966/request-confirmation?taskId=test-task-id`** — Request confirmation from the user.
-```json
-{"description":"..."}
-```
-- `description` (required, string): What the user is confirming
-- The request blocks until the user confirms or aborts.
-- Response: `{"confirmed": true}` or `{"confirmed": false}`.
-
-**`POST http://localhost:9966/device-geolocation?taskId=test-task-id`** — 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.
-
-The task to execute follows below:
-
----
-
-Test task prompt