palmier 0.2.5 → 0.2.6

package/README.md

@@ -1,219 +1,288 @@
-# Palmier
-
-A Node.js CLI that runs on your machine as a persistent daemon. It manages tasks, communicates with the Palmier app via NATS and/or direct HTTP, and executes tasks on schedule or demand using CLI tools.
-
-## Connection Modes
-
-The host supports three connection modes:
-
-| Mode | Transport | Setup | Features |
-|------|-----------|-------|----------|
-| **`nats`** | NATS only | `palmier init` → Full access, skip LAN | All features |
-| **`auto`** | Both NATS + HTTP | `palmier init` → Full access + LAN | All features. PWA auto-detects best route. |
-| **`lan`** | HTTP only | `palmier init` → LAN only | No push notifications or email MCP. No server needed. |
-
-In **auto** mode, the PWA connects directly to the host via HTTP when on the same LAN (lower latency), and falls back to NATS when the host is unreachable. Push notifications and email relay always flow through NATS/server, so no features are lost.
-
-In **lan** mode, the host runs a standalone HTTP server. Multiple PWA clients can connect using session tokens. No Palmier web server or NATS broker is needed.
-
-## Prerequisites
-
-- **Node.js 20+**
-- An agent CLI tool for task execution (e.g., Claude Code, Gemini CLI, OpenAI Codex)
-- **Linux with systemd** (the host installs as a systemd user service)
-
-## Installation
-
-```bash
-npm install -g palmier
-```
-
-## CLI Commands
-
-| Command | Description |
-|---|---|
-| `palmier init` | Interactive setup wizard (full access or LAN only) |
-| `palmier pair` | Generate an OTP code to pair a new device |
-| `palmier sessions list` | List active session tokens |
-| `palmier sessions revoke <token>` | Revoke a specific session token |
-| `palmier sessions revoke-all` | Revoke all session tokens |
-| `palmier info` | Show host connection info (address, mode) |
-| `palmier serve` | Run the persistent RPC handler (default command) |
-| `palmier run <task-id>` | Execute a specific task |
-| `palmier mcpserver` | Start an MCP server exposing Palmier tools (stdio transport) |
-| `palmier agents` | Re-detect installed agent CLIs and update config |
-
-## Setup
-
-### Quick Start
-
-1. Install the host: `npm install -g palmier`
-2. Run `palmier init` in your project directory.
-3. The wizard walks you through:
-   - **Full access** or **LAN only** mode
-   - Server URL (for full access, defaults to `https://www.palmier.me`)
-   - Optional LAN access (for full access — auto-detects best route when enabled)
-4. The host saves config, installs a systemd service, and generates a pairing code.
-5. Enter the pairing code in the Palmier PWA to connect your device.
-
-### Pairing additional devices
-
-Run `palmier pair` on the host to generate a new OTP code. Each paired device gets its own session token.
-
-### Managing sessions
-
-```bash
-# List all paired devices
-palmier sessions list
-
-# Revoke a specific device's access
-palmier sessions revoke <token>
-
-# Revoke all sessions (unpair all devices)
-palmier sessions revoke-all
-```
-
-The `init` command:
-- Detects installed agent CLIs (Claude Code, Gemini CLI, Codex CLI) and caches the result
-- Saves host configuration to `~/.config/palmier/host.json`
-- Installs a systemd user service for the host
-- Auto-enters pair mode to connect your first device
-
-To re-detect agents after installing or removing a CLI, run `palmier agents`.
-
-### Verifying the Service
-
-After `palmier init`, verify the host is running:
-
-```bash
-# Check service status
-systemctl --user status palmier.service
-
-# View recent logs
-journalctl --user -u palmier.service -n 50 --no-pager
-
-# Follow logs in real time
-journalctl --user -u palmier.service -f
-```
-
-You should see `Active: active (running)` and log output showing a NATS connection. If the service failed:
-
-```bash
-# Restart manually
-systemctl --user restart palmier.service
-
-# Check config is valid
-cat ~/.config/palmier/host.json
-```
-
-## How It Works
-
-- The host runs as a **systemd user service**, staying alive in the background via `palmier serve`.
-- **Paired devices** communicate with the host via NATS (cloud-routed) and/or direct HTTP (LAN), depending on the connection mode. Each paired device gets a session token that authenticates all requests.
-- **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional triggers (cron schedules or one-time dates).
-- **Plan generation** is automatic — when you create or update a task, the host invokes your chosen agent CLI to generate an execution plan and name.
-- **Triggers** are backed by systemd timers. You can enable/disable them without deleting the task, and any task can still be run manually at any time.
-- **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (NATS mode) or a prompt in the PWA to confirm or abort.
-- **Run history** — each run produces a timestamped result file. You can view results and reports from the PWA.
-- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub or SSE.
-- **MCP server** (`palmier mcpserver`) exposes platform tools (e.g., `send-email`) to AI agents like Claude Code over stdio.
-
-## Project Structure
-
-```
-src/
-  index.ts            # CLI entrypoint (commander setup)
-  config.ts           # Host configuration (read/write ~/.config/palmier)
-  rpc-handler.ts      # Transport-agnostic RPC handler (with session validation)
-  session-store.ts    # Session token management (~/.config/palmier/sessions.json)
-  nats-client.ts      # NATS connection helper
-  spawn-command.ts    # Shared helper for spawning CLI tools without a shell
-  systemd.ts          # systemd service installation
-  task.ts             # Task file management
-  types.ts            # Shared type definitions
-  agents/
-    agent.ts          # AgentTool interface, registry, and agent detection
-    claude.ts         # Claude Code agent implementation
-    gemini.ts         # Gemini CLI agent implementation
-    codex.ts          # Codex CLI agent implementation
-    openclaw.ts       # OpenClaw agent implementation
-  commands/
-    init.ts           # Interactive setup wizard (auto-pair)
-    pair.ts           # OTP code generation and pairing handler
-    sessions.ts       # Session token management CLI (list, revoke, revoke-all)
-    info.ts           # Print host connection info
-    agents.ts         # Re-detect installed agent CLIs
-    serve.ts          # Transport selection and startup
-    run.ts            # Single task execution
-    mcpserver.ts      # MCP server with platform tools (send-email)
-  transports/
-    nats-transport.ts # NATS subscription loop (host.<hostId>.rpc.>)
-    http-transport.ts # HTTP server with RPC, SSE, and internal event endpoints
-```
-
-## MCP Server
-
-The host includes an MCP server that exposes Palmier platform tools to AI agents like Claude Code.
-
-### Setup
-
-Add to your Claude Code MCP settings:
-
-```json
-{
-  "mcpServers": {
-    "palmier": {
-      "command": "palmier",
-      "args": ["mcpserver"]
-    }
-  }
-}
-```
-
-Requires a provisioned host (`palmier init`). In NATS/auto mode, uses NATS relay. In LAN mode with `serverUrl` configured, uses HTTP relay. Not available in standalone LAN mode without a server.
-
-### Available Tools
-
-| Tool | Inputs | Description |
-|---|---|---|
-| `send-email` | `to`, `subject`, `text` (required); `html`, `reply_to`, `cc`, `bcc` (optional) | Send an email via the platform's SMTP relay |
-
-## Removing a Host
-
-To fully remove a host from a machine:
-
-1. **Unpair the host from the PWA** (via the host menu).
-
-2. **Stop and remove the systemd service:**
-
-   ```bash
-   systemctl --user stop palmier.service
-   systemctl --user disable palmier.service
-   rm ~/.config/systemd/user/palmier.service
-   ```
-
-3. **Remove any task timers and services:**
-
-   ```bash
-   systemctl --user stop palmier-task-*.timer palmier-task-*.service 2>/dev/null
-   systemctl --user disable palmier-task-*.timer 2>/dev/null
-   rm -f ~/.config/systemd/user/palmier-task-*.timer ~/.config/systemd/user/palmier-task-*.service
-   ```
-
-4. **Reload systemd:**
-
-   ```bash
-   systemctl --user daemon-reload
-   ```
-
-5. **Remove the host configuration:**
-
-   ```bash
-   rm -rf ~/.config/palmier
-   ```
-
-6. **Remove the tasks directory** from your project root:
-
-   ```bash
-   rm -rf tasks/
-   ```
+# Palmier
+
+![CI](https://github.com/caihongxu/palmier/actions/workflows/ci.yml/badge.svg)
+
+A Node.js CLI that runs on your machine as a persistent daemon. It manages tasks, communicates with the Palmier app via NATS and/or direct HTTP, and executes tasks on schedule or demand using CLI tools.
+
+> **Important:** By using Palmier, you agree to the [Terms of Service](https://www.palmier.me/terms) and [Privacy Policy](https://www.palmier.me/privacy). See the [Disclaimer](#disclaimer) section below.
+
+## Connection Modes
+
+The host supports three connection modes:
+
+| Mode | Transport | Setup | Features |
+|------|-----------|-------|----------|
+| **`nats`** | NATS only | `palmier init` → Full access, skip LAN | All features |
+| **`auto`** | Both NATS + HTTP | `palmier init` → Full access + LAN | All features. PWA auto-detects best route. |
+| **`lan`** | HTTP only | `palmier init` → LAN only | No push notifications. No server needed. |
+
+In **auto** mode, the PWA connects directly to the host via HTTP when on the same LAN (lower latency), and falls back to NATS when the host is unreachable. Push notifications always flow through NATS/server, so no features are lost.
+
+In **lan** mode, the host runs a standalone HTTP server. Multiple PWA clients can connect using session tokens. No Palmier web server or NATS broker is needed.
+
+## Prerequisites
+
+- **Node.js 24+**
+- An agent CLI tool for task execution (e.g., Claude Code, Gemini CLI, OpenAI Codex)
+- **Linux with systemd** or **Windows 10/11**
+
+## Installation
+
+```bash
+npm install -g palmier
+```
+
+## CLI Commands
+
+| Command | Description |
+|---|---|
+| `palmier init` | Interactive setup wizard (full access or LAN only) |
+| `palmier pair` | Generate an OTP code to pair a new device |
+| `palmier sessions list` | List active session tokens |
+| `palmier sessions revoke <token>` | Revoke a specific session token |
+| `palmier sessions revoke-all` | Revoke all session tokens |
+| `palmier info` | Show host connection info (address, mode) |
+| `palmier serve` | Run the persistent RPC handler (default command) |
+| `palmier restart` | Restart the palmier serve daemon |
+| `palmier run <task-id>` | Execute a specific task |
+| `palmier mcpserver` | Start an MCP server exposing Palmier tools (stdio transport) |
+| `palmier agents` | Re-detect installed agent CLIs and update config |
+
+## Setup
+
+### Quick Start
+
+1. Install the host: `npm install -g palmier`
+2. Run `palmier init` in your project directory.
+3. The wizard walks you through:
+   - **Full access** or **LAN only** mode
+   - Server URL (for full access, used for registration only — not stored in config)
+   - Optional LAN access (for full access — auto-detects best route when enabled)
+4. The host saves config, installs a background daemon (systemd on Linux, Registry Run key on Windows), and generates a pairing code.
+5. Enter the pairing code in the Palmier PWA to connect your device.
+
+### Pairing additional devices
+
+Run `palmier pair` on the host to generate a new OTP code. Each paired device gets its own session token.
+
+### Managing sessions
+
+```bash
+# List all paired devices
+palmier sessions list
+
+# Revoke a specific device's access
+palmier sessions revoke <token>
+
+# Revoke all sessions (unpair all devices)
+palmier sessions revoke-all
+```
+
+The `init` command:
+- Detects installed agent CLIs (Claude Code, Gemini CLI, Codex CLI) and caches the result
+- Saves host configuration to `~/.config/palmier/host.json`
+- Installs a background daemon (systemd user service on Linux, Registry Run key on Windows)
+- Auto-enters pair mode to connect your first device
+
+To re-detect agents after installing or removing a CLI, run `palmier agents`.
+
+### Verifying the Service
+
+After `palmier init`, verify the host is running:
+
+**Linux:**
+
+```bash
+# Check service status
+systemctl --user status palmier.service
+
+# View recent logs
+journalctl --user -u palmier.service -n 50 --no-pager
+
+# Follow logs in real time
+journalctl --user -u palmier.service -f
+```
+
+**Windows (PowerShell):**
+
+```powershell
+# Check if the daemon is running
+Get-Process -Name node -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*palmier*serve*' }
+```
+
+**Restarting the daemon (both platforms):**
+
+```bash
+palmier restart
+```
+
+## How It Works
+
+- The host runs as a **background daemon** (systemd user service on Linux, Registry Run key on Windows), staying alive via `palmier serve`.
+- **Paired devices** communicate with the host via NATS (cloud-routed) and/or direct HTTP (LAN), depending on the connection mode. Each paired device gets a session token that authenticates all requests.
+- **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional triggers (cron schedules or one-time dates).
+- **Plan generation** is automatic — when you create or update a task, the host invokes your chosen agent CLI to generate an execution plan and name.
+- **Triggers** are backed by systemd timers (Linux) or Task Scheduler (Windows). You can enable/disable them without deleting the task, and any task can still be run manually at any time.
+- **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
+- **Command-triggered tasks** — optionally specify a shell command (e.g., `tail -f /var/log/app.log`). Palmier runs the command continuously and invokes the agent for each line of stdout, passing it alongside your prompt. Useful for log monitoring, event-driven automation, and reactive workflows.
+- **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (NATS mode) or a prompt in the PWA to confirm or abort.
+- **Run history** — each run produces a timestamped result file. You can view results and reports from the PWA.
+- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub or SSE. A shared events module handles broadcasting across both transports.
+- **MCP server** (`palmier mcpserver`) exposes platform tools (e.g., `send-push-notification`) to AI agents like Claude Code over stdio.
+
+## Project Structure
+
+```
+src/
+  index.ts            # CLI entrypoint (commander setup)
+  config.ts           # Host configuration (read/write ~/.config/palmier)
+  rpc-handler.ts      # Transport-agnostic RPC handler (with session validation)
+  session-store.ts    # Session token management (~/.config/palmier/sessions.json)
+  nats-client.ts      # NATS connection helper
+  spawn-command.ts    # Shared helper for spawning CLI tools
+  task.ts             # Task file management
+  types.ts            # Shared type definitions
+  agents/
+    agent.ts          # AgentTool interface, registry, and agent detection
+    claude.ts         # Claude Code agent implementation
+    gemini.ts         # Gemini CLI agent implementation
+    codex.ts          # Codex CLI agent implementation
+    openclaw.ts       # OpenClaw agent implementation
+  events.ts           # Shared event broadcasting (NATS pub/sub and HTTP SSE)
+  commands/
+    init.ts           # Interactive setup wizard (auto-pair)
+    pair.ts           # OTP code generation and pairing handler
+    sessions.ts       # Session token management CLI (list, revoke, revoke-all)
+    info.ts           # Print host connection info
+    agents.ts         # Re-detect installed agent CLIs
+    serve.ts          # Transport selection, startup, and crash detection polling
+    restart.ts        # Daemon restart (cross-platform)
+    run.ts            # Single task execution
+    mcpserver.ts      # MCP server with platform tools (send-push-notification)
+  platform/
+    platform.ts       # PlatformService interface
+    index.ts          # Platform factory (Linux vs Windows)
+    linux.ts          # Linux: systemd daemon, timers, systemctl task control
+    windows.ts        # Windows: Registry Run key, Task Scheduler, schtasks-based task control
+  transports/
+    nats-transport.ts # NATS subscription loop (host.<hostId>.rpc.>)
+    http-transport.ts # HTTP server with RPC, SSE, and internal event endpoints
+```
+
+## MCP Server
+
+The host includes an MCP server that exposes Palmier platform tools to AI agents like Claude Code.
+
+### Setup
+
+Add to your Claude Code MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "palmier": {
+      "command": "palmier",
+      "args": ["mcpserver"]
+    }
+  }
+}
+```
+
+Requires a provisioned host (`palmier init`). In NATS/auto mode, uses NATS relay. Not available in LAN-only mode.
+
+### Available Tools
+
+| Tool | Inputs | Description |
+|---|---|---|
+| `send-push-notification` | `title`, `body` (required) | Send a push notification to all paired devices |
+
+## Removing a Host
+
+To fully remove a host from a machine:
+
+1. **Unpair the host from the PWA** (via the host menu).
+
+2. **Stop and remove the daemon:**
+
+   **Linux:**
+   ```bash
+   systemctl --user stop palmier.service
+   systemctl --user disable palmier.service
+   rm ~/.config/systemd/user/palmier.service
+   ```
+
+   **Windows (PowerShell):**
+   ```powershell
+   # Kill the daemon process
+   Get-Content "$env:USERPROFILE\.config\palmier\daemon.pid" | ForEach-Object { Stop-Process -Id $_ -Force -ErrorAction SilentlyContinue }
+   # Remove the Registry Run key
+   Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" -Name "PalmierDaemon" -ErrorAction SilentlyContinue
+   ```
+
+3. **Remove any task timers:**
+
+   **Linux:**
+   ```bash
+   systemctl --user stop palmier-task-*.timer palmier-task-*.service 2>/dev/null
+   systemctl --user disable palmier-task-*.timer 2>/dev/null
+   rm -f ~/.config/systemd/user/palmier-task-*.timer ~/.config/systemd/user/palmier-task-*.service
+   systemctl --user daemon-reload
+   ```
+
+   **Windows (PowerShell):**
+   ```powershell
+   schtasks /delete /tn "PalmierTask-*" /f 2>$null
+   ```
+
+4. **Remove the host configuration:**
+
+   ```bash
+   rm -rf ~/.config/palmier
+   ```
+
+5. **Remove the tasks directory** from your project root:
+
+   ```bash
+   rm -rf tasks/
+   ```
+
+## Disclaimer
+
+**USE AT YOUR OWN RISK.** Palmier is provided on an "AS IS" and "AS AVAILABLE" basis, without warranties of any kind, either express or implied.
+
+### AI Agent Execution
+
+Palmier spawns third-party AI agent CLIs (such as Claude Code, Gemini CLI, and Codex CLI) that can:
+
+- **Read, create, modify, and delete files** on your machine
+- **Execute arbitrary shell commands** with your user permissions
+- **Make network requests** and interact with external services
+
+AI agents may produce unexpected, incorrect, or harmful outputs. **You are solely responsible for reviewing and approving all actions taken by AI agents on your system.** The authors of Palmier have no control over the behavior of third-party AI agents and accept no liability for their actions.
+
+### Unattended and Scheduled Execution
+
+Tasks can be configured to run on schedules (cron) or in response to events without active supervision. You should:
+
+- Use the **confirmation** feature for sensitive tasks
+- Restrict **permissions** granted to agents to the minimum necessary
+- Regularly review **task history and results**
+- Maintain **backups** of any important data in directories where agents operate
+
+### Third-Party Services
+
+Task prompts and execution data may be transmitted to third-party AI service providers (Anthropic, Google, OpenAI, etc.) according to their respective terms and privacy policies. Palmier does not control how these services process your data.
+
+When using NATS or auto mode, communication between your device and the host is relayed through the Palmier server. See the [Privacy Policy](https://www.palmier.me/privacy) for details on what data is collected.
+
+### Limitation of Liability
+
+To the maximum extent permitted by applicable law, the authors and contributors of Palmier shall not be liable for any direct, indirect, incidental, special, consequential, or exemplary damages arising from the use of this software, including but not limited to damages for loss of data, loss of profits, business interruption, or any other commercial damages or losses.
+
+### No Professional Advice
+
+Palmier is a developer tool, not a substitute for professional advice. Do not rely on AI-generated outputs for critical decisions without independent verification.
+
+## License
+
+This project is licensed under the Apache License 2.0. See [LICENSE](LICENSE) for the full text.

package/dist/agents/agent.d.ts

@@ -2,6 +2,8 @@ import type { ParsedTask, RequiredPermission } from "../types.js";
 export interface CommandLine {
     command: string;
     args: string[];
+    /** If provided, the string is written to the process's stdin and then the pipe is closed. */
+    stdin?: string;
 }
 /**
  * Interface that each agent tool must implement.
@@ -10,9 +12,10 @@ export interface CommandLine {
 export interface AgentTool {
     /** Return the command and args used to generate a plan from a prompt. */
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    /** Return the command and args used to run a task. If prompt is provided, use it instead of the task's prompt.
-     *  extraPermissions are transient permissions granted for this run only (not persisted in frontmatter). */
-    getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    /** Return the command and args used to run a task. If retryPrompt is provided, use it instead of the task's prompt,
+     *  and treat it as a continuation of the original run (reuse the same session, etc). extraPermissions are transient
+     *  permissions granted for this run only (not persisted in frontmatter). */
+    getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
     /** Detect whether the agent CLI is available and perform any agent-specific
      *  initialization. Returns true if the agent was detected and initialized successfully. */
     init(): Promise<boolean>;

package/dist/agents/agent.js

@@ -1,10 +1,12 @@
 import { ClaudeAgent } from "./claude.js";
 import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
+import { OpenClawAgent } from "./openclaw.js";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
     codex: new CodexAgent(),
+    openclaw: new OpenClawAgent(),
 };
 const agentLabels = {
     claude: "Claude Code",

package/dist/agents/claude.d.ts

@@ -2,7 +2,7 @@ import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class ClaudeAgent implements AgentTool {
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=claude.d.ts.map

package/dist/agents/claude.js

@@ -1,5 +1,5 @@
 import { execSync } from "child_process";
-import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
 // execSync's shell option takes a string (shell path), not boolean.
 // On Windows we need a shell so .cmd shims resolve correctly.
 const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
@@ -10,27 +10,30 @@ export class ClaudeAgent {
             args: ["-p", prompt],
         };
     }
-    getTaskRunCommandLine(task, prompt, extraPermissions) {
-        prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
-        const args = ["-c", "--permission-mode", "acceptEdits", "-p", prompt];
+    getTaskRunCommandLine(task, retryPrompt, extraPermissions) {
+        const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
+        const args = ["--permission-mode", "acceptEdits", "--append-system-prompt", AGENT_INSTRUCTIONS, "-p"];
         const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
         for (const p of allPerms) {
             args.push("--allowedTools", p.name);
         }
-        return { command: "claude", args };
+        if (retryPrompt) {
+            args.push("-c");
+        } // continue mode for retries
+        return { command: "claude", args, stdin: prompt };
     }
     async init() {
         try {
-            execSync("claude --version", { shell: SHELL });
+            execSync("claude --version", { stdio: "ignore", shell: SHELL });
         }
         catch {
             return false;
         }
         try {
-            execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { shell: SHELL });
+            execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { stdio: "ignore", shell: SHELL });
         }
-        catch (err) {
-            console.warn("Warning: failed to install MCP for Claude:", err instanceof Error ? err.message : err);
+        catch {
+            // MCP registration is best-effort; agent still works without it
         }
         return true;
     }

package/dist/agents/codex.d.ts

@@ -2,7 +2,7 @@ import type { ParsedTask, RequiredPermission } from "../types.js";
 import type { AgentTool, CommandLine } from "./agent.js";
 export declare class CodexAgent implements AgentTool {
     getPlanGenerationCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
     init(): Promise<boolean>;
 }
 //# sourceMappingURL=codex.d.ts.map