palmier 0.2.0 → 0.2.1

package/CLAUDE.md

@@ -2,4 +2,8 @@
 
 ## Getting Started
 
-Always read `spec.md` and `README.md` first before starting any task. These files contain the project specification and setup instructions that should inform all work.
+Always read `README.md` first before starting any task. For the full platform architecture spec (NATS protocol, data model, execution flow), see `spec.md` in the [palmier-server](../palmier-server) repo.
+
+## Documentation
+
+When making architectural changes, update `README.md` and the server repo's `spec.md` to reflect the new state.

package/README.md

@@ -1,12 +1,26 @@
-# Palmier Agent
+# Palmier
 
-A Node.js CLI that runs on your machine as a persistent agent. It manages tasks, communicates with the Palmier platform via NATS, and executes Claude Code autonomously.
+A Node.js CLI that runs on your machine as a persistent daemon. It manages tasks, communicates with the Palmier platform via NATS and/or direct HTTP, and executes CLI tools autonomously.
+
+## Connection Modes
+
+The host supports three connection modes:
+
+| Mode | Transport | Setup | Features |
+|------|-----------|-------|----------|
+| **`nats`** | NATS only | `palmier init --server <url>` → select nats | All features |
+| **`auto`** | Both NATS + HTTP | `palmier init --server <url>` → select auto | All features. PWA auto-detects best route. |
+| **`lan`** | HTTP only | `palmier init --lan` | 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+**
-- **Claude Code CLI** installed and authenticated
-- **Linux with systemd** (the agent installs as a systemd user service)
+- 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
 
@@ -18,87 +32,173 @@ npm install -g palmier
 
 | Command | Description |
 |---|---|
-| `palmier init --token <token>` | Provision the agent with a token from the dashboard |
-| `palmier serve` | Run the persistent NATS RPC handler (default command) |
+| `palmier init --server <url>` | Provision the host via the server (prompts for nats/auto mode) |
+| `palmier init --lan` | Provision standalone LAN host (no server needed) |
+| `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
 
-1. Install the agent: `npm install -g palmier`
-2. Register on the Palmier PWA and click **Add Agent**.
-3. Copy the provisioning token.
-4. Run `palmier init --token <token>` in your project directory.
+### Server-provisioned (nats or auto mode)
+
+1. Install the host: `npm install -g palmier`
+2. Run `palmier init --server https://your-server-url` in your project directory.
+3. Select connection mode: `auto` (recommended) or `nats`.
+4. The host registers with the server, saves config, installs a systemd service, and generates a pairing code.
+5. Enter the pairing code in the Palmier PWA to connect your device.
+
+### Standalone LAN mode
+
+1. Install the host: `npm install -g palmier`
+2. Run `palmier init --lan` in your project directory.
+3. A pairing code and address are displayed. Enter both in the PWA.
+
+### 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:
-- Saves agent configuration to `~/.config/palmier/agent.json`
-- Installs a systemd user service for the agent
+- 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 agent is running:
+After `palmier init`, verify the host is running:
 
 ```bash
 # Check service status
-systemctl --user status palmier-agent.service
+systemctl --user status palmier.service
 
 # View recent logs
-journalctl --user -u palmier-agent.service -n 50 --no-pager
+journalctl --user -u palmier.service -n 50 --no-pager
 
 # Follow logs in real time
-journalctl --user -u palmier-agent.service -f
+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-agent.service
+systemctl --user restart palmier.service
 
 # Check config is valid
-cat ~/.config/palmier/agent.json
+cat ~/.config/palmier/host.json
 ```
 
 ## How It Works
 
-- The agent runs as a **systemd user service**, staying alive in the background.
-- The persistent process (`palmier serve`) is a NATS RPC handler. It derives the RPC method from the NATS subject (e.g., `...rpc.task.create` → `task.create`) and treats the message body as request parameters.
-- **Task IDs** are generated by the agent as UUIDs.
+- The host runs as a **systemd user service**, staying alive in the background.
+- The persistent process (`palmier serve`) is an RPC handler. In NATS mode, it derives the method from the NATS subject; in LAN/auto mode, it exposes HTTP endpoints (`POST /rpc/<method>`). The RPC handler (`src/rpc-handler.ts`) is transport-agnostic.
+- **Session tokens** — every RPC request includes a `sessionToken` (in the NATS JSON payload or as an HTTP Bearer token). The host validates the token against `~/.config/palmier/sessions.json` before processing the request. If no sessions exist, validation is skipped.
+- **Task IDs** are generated by the host as UUIDs.
 - All RPC responses (`task.list`, `task.create`, `task.update`) return **flat task objects** — frontmatter fields at the top level, not nested under a `frontmatter` key.
+- **Plan generation is automatic** — `task.create` and `task.update` generate an execution plan and task name by invoking the configured agent CLI. For `task.update`, plans are regenerated only when `user_prompt` or `agent` changes, or when no plan body exists yet.
+- **Run history** — each task run produces a time-stamped result file (`RESULT-<timestamp>.md`) and a task snapshot (`TASK-<timestamp>.md`) in the task directory. A project-level `history.jsonl` file indexes all runs with `{ task_id, result_file }` entries. The `activity.list` RPC reads this index with pagination (`offset`/`limit`, optional `task_id` filter) and enriches each entry with RESULT frontmatter. The `task.result` RPC requires a `result_file` parameter identifying which result to read.
+- The `task.reports` RPC reads one or more report files (each must end with `.md`, plain filenames only) from a task's directory. If the RESULT frontmatter includes a `report_files` field, the PWA shows clickable links in the result dialog that fetch and display each report.
 - Tasks have no separate name field — the `user_prompt` is the primary identifier and display label.
-- Plan generation is optional — if no plan body is present, the agent uses only `user_prompt` as the prompt.
 - **Triggers can be enabled/disabled** via the `triggers_enabled` frontmatter field (default `true`). When disabled, systemd timers are removed; when re-enabled, they are reinstalled. Tasks can still be run manually regardless.
 - Incoming tasks are stored as `TASK.md` files in a local `tasks/` directory.
-- Task execution spawns **Claude Code as a background process** with `-p --dangerously-skip-permissions`, running non-interactively. Task lifecycle events (`start`, `finish`, `abort`, `fail`) are tracked via a NATS JetStream KV bucket (`task-event`), keyed by `<agent_id>.<task_id>`.
-- **Task confirmation** — tasks with `requires_confirmation: true` write a pending entry to the `pending-confirmation` KV bucket before execution. The Web Server and PWA watch this bucket to show confirmation prompts. The task waits until the user confirms or aborts via the PWA or push notification.
+- Task execution is abstracted through an **`AgentTool` interface** (`src/agents/agent.ts`). Each task stores an `agent` field (e.g., `"claude"`) that selects which agent implementation constructs the full command line and arguments. The agent's `getTaskRunCommandLine(task)` method builds the appropriate flags (e.g., `--allowedTools` for Claude based on task permissions). The process is spawned without a shell, and stdin is closed to prevent tools from hanging on an open pipe. The spawned process inherits the default physical GUI session environment (`DISPLAY=:0`) so commands that launch graphical applications (e.g., headed browsers) run within the user's desktop session. Task lifecycle status (`start`, `finish`, `abort`, `fail`) is persisted to a `status.json` file in the task directory. Status changes are broadcast on a unified `host-event.<host_id>.<task_id>` subject via NATS pub/sub (when available) and/or pushed through SSE (in LAN/auto mode) by `run.ts` POSTing to the serve process's `/internal/event` endpoint. All events carry an `event_type` field (`"running-state"`, `"confirm-request"`, or `"confirm-resolved"`) with the same payload shape on both transports. Consumers (PWA, Web Server) subscribe to these notifications and fetch full status from the host via the `task.status` RPC.
+- **Task confirmation** — tasks with `requires_confirmation: true` set `pending_confirmation: true` in `status.json` before execution. A `confirm-request` event is published on `host-event` so the Web Server can send push notifications and connected PWA clients show a confirmation dialog. The user confirms or aborts via the PWA, which calls the `task.user_input` RPC on the host. The `serve` process sets `user_input` to the user's response (e.g., `"confirmed"` or `"aborted"`), and `run` watches the file for `user_input` to become defined, then updates `running_state` accordingly.
+- **MCP server** (`palmier mcpserver`) — starts an MCP server over stdio that exposes platform tools to AI agents (e.g., Claude Code). In NATS/auto mode, connects to NATS on startup. Currently exposes a `send-email` tool that relays email requests to the Web Server via NATS (`host.<host_id>.email.send`).
 
 ## Project Structure
 
 ```
 src/
   index.ts            # CLI entrypoint (commander setup)
-  config.ts           # Agent configuration (read/write ~/.config/palmier)
-  nats-client.ts      # NATS connection and messaging
+  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           # Provisioning logic
-    serve.ts          # Persistent NATS RPC handler
+    init.ts           # Provisioning logic (--server and --lan flows, 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"]
+    }
+  }
+}
 ```
 
-## Removing an Agent
+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
 
-To fully remove an agent from a machine:
+| Tool | Inputs | Description |
+|---|---|---|
+| `send-email` | `to`, `subject`, `text` (required); `html`, `reply_to`, `cc`, `bcc` (optional) | Send an email via the platform's SMTP relay |
 
-1. **Delete the agent from the PWA dashboard** (this removes it from the server database).
+## 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-agent.service
-   systemctl --user disable palmier-agent.service
-   rm ~/.config/systemd/user/palmier-agent.service
+   systemctl --user stop palmier.service
+   systemctl --user disable palmier.service
+   rm ~/.config/systemd/user/palmier.service
    ```
 
 3. **Remove any task timers and services:**
@@ -115,7 +215,7 @@ To fully remove an agent from a machine:
    systemctl --user daemon-reload
    ```
 
-5. **Remove the agent configuration:**
+5. **Remove the host configuration:**
 
    ```bash
    rm -rf ~/.config/palmier
@@ -126,13 +226,3 @@ To fully remove an agent from a machine:
    ```bash
    rm -rf tasks/
    ```
-
-7. *(Optional)* **Disable login lingering** if no other user services need it:
-
-   ```bash
-   loginctl disable-linger
-   ```
-
-## Related
-
-See the [palmier](../palmier) repo for the server, API, and PWA.

package/dist/agents/agent.d.ts

@@ -0,0 +1,26 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+export interface CommandLine {
+    command: string;
+    args: string[];
+}
+/**
+ * Interface that each agent tool must implement.
+ * Abstracts how plans are generated and tasks are executed across different AI agents.
+ */
+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;
+    /** 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>;
+}
+export interface DetectedAgent {
+    key: string;
+    label: string;
+}
+export declare function detectAgents(): Promise<DetectedAgent[]>;
+export declare function getAgent(name: string): AgentTool;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agents/agent.js

@@ -0,0 +1,32 @@
+import { ClaudeAgent } from "./claude.js";
+import { GeminiAgent } from "./gemini.js";
+import { CodexAgent } from "./codex.js";
+const agentRegistry = {
+    claude: new ClaudeAgent(),
+    gemini: new GeminiAgent(),
+    codex: new CodexAgent(),
+};
+const agentLabels = {
+    claude: "Claude Code",
+    gemini: "Gemini CLI",
+    codex: "Codex CLI",
+    openclaw: "OpenClaw"
+};
+export async function detectAgents() {
+    const detected = [];
+    for (const [key, agent] of Object.entries(agentRegistry)) {
+        const label = agentLabels[key] ?? key;
+        const ok = await agent.init();
+        if (ok)
+            detected.push({ key, label });
+    }
+    return detected;
+}
+export function getAgent(name) {
+    const agent = agentRegistry[name];
+    if (!agent) {
+        throw new Error(`Unknown agent: "${name}". Available agents: ${Object.keys(agentRegistry).join(", ")}`);
+    }
+    return agent;
+}
+//# sourceMappingURL=agent.js.map

package/dist/agents/claude.d.ts

@@ -0,0 +1,8 @@
+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;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=claude.d.ts.map

package/dist/agents/claude.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+export class ClaudeAgent {
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "claude",
+            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];
+        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+        for (const p of allPerms) {
+            args.push("--allowedTools", p.name);
+        }
+        return { command: "claude", args };
+    }
+    async init() {
+        try {
+            execSync("claude --version");
+        }
+        catch {
+            return false;
+        }
+        try {
+            execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver");
+        }
+        catch (err) {
+            console.warn("Warning: failed to install MCP for Claude:", err instanceof Error ? err.message : err);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/agents/codex.d.ts

@@ -0,0 +1,8 @@
+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;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=codex.d.ts.map

package/dist/agents/codex.js

@@ -0,0 +1,41 @@
+import { execSync } from "child_process";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+export class CodexAgent {
+    getPlanGenerationCommandLine(prompt) {
+        // TODO: fill in
+        return {
+            command: "codex",
+            args: ["exec", "--skip-git-repo-check", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, prompt, extraPermissions) {
+        prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+        // TODO: Update sandbox to workspace-write once https://github.com/openai/codex/issues/12572
+        // is fixed.
+        const args = ["exec", "--full-auto", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
+        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+        for (const p of allPerms) {
+            args.push("--config");
+            args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
+        }
+        args.push(prompt);
+        args.push("resume", "--last");
+        return { command: "codex", args };
+    }
+    async init() {
+        try {
+            execSync("codex --version");
+        }
+        catch {
+            return false;
+        }
+        try {
+            execSync("codex mcp add palmier palmier mcpserver");
+        }
+        catch (err) {
+            console.warn("Warning: failed to install MCP for Codex:", err instanceof Error ? err.message : err);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=codex.js.map

package/dist/agents/gemini.d.ts

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

package/dist/agents/gemini.js

@@ -0,0 +1,39 @@
+import { execSync } from "child_process";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+export class GeminiAgent {
+    getPlanGenerationCommandLine(prompt) {
+        // TODO: fill in
+        return {
+            command: "gemini",
+            args: ["--approval-mode", "auto_edit", "--prompt", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, prompt, extraPermissions) {
+        prompt = prompt ?? (task.body || task.frontmatter.user_prompt);
+        const args = ["--resume", "--prompt", prompt + TASK_OUTCOME_SUFFIX];
+        const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+        if (allPerms.length > 0) {
+            args.push("--allowed-tools");
+            for (const p of allPerms) {
+                args.push(p.name);
+            }
+        }
+        return { command: "gemini", args };
+    }
+    async init() {
+        try {
+            execSync("gemini --version");
+        }
+        catch {
+            return false;
+        }
+        try {
+            execSync("gemini mcp add --scope user palmier palmier mcpserver");
+        }
+        catch (err) {
+            console.warn("Warning: failed to install MCP for Gemini:", err instanceof Error ? err.message : err);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=gemini.js.map

package/dist/agents/openclaw.d.ts

@@ -0,0 +1,8 @@
+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;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=openclaw.d.ts.map

package/dist/agents/openclaw.js

@@ -0,0 +1,25 @@
+import { execSync } from "child_process";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+export class ClaudeAgent {
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "openclaw",
+            args: ["agent", "--message", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, prompt, extraPermissions) {
+        prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+        const args = ["agent", "--message", prompt];
+        return { command: "openclaw", args };
+    }
+    async init() {
+        try {
+            execSync("openclaw --version");
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=openclaw.js.map

package/dist/agents/shared-prompt.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Appended to the end of every task prompt.
+ * Instructs the agent to output a clear success/failure marker
+ * so that palmier can determine the task outcome.
+ */
+export declare const TASK_OUTCOME_SUFFIX = "\n\n---\nIf you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.\n[PALMIER_REPORT] report.md\n[PALMIER_REPORT] summary.md\n\nWhen you are done, output exactly one of these markers as the very last line:\n- Success: [PALMIER_TASK_SUCCESS]\n- Failure: [PALMIER_TASK_FAILURE]\nDo not wrap them in code blocks or add text on the same line.\n\nIf the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]: e.g.\n[PALMIER_PERMISSION] Read | Read file contents from the repository\n[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm\n[PALMIER_PERMISSION] Write | Write generated output files";
+export declare const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
+export declare const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
+export declare const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";
+export declare const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
+//# sourceMappingURL=shared-prompt.d.ts.map

package/dist/agents/shared-prompt.js

@@ -0,0 +1,26 @@
+/**
+ * Appended to the end of every task prompt.
+ * Instructs the agent to output a clear success/failure marker
+ * so that palmier can determine the task outcome.
+ */
+export const TASK_OUTCOME_SUFFIX = `
+
+---
+If you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.
+[PALMIER_REPORT] report.md
+[PALMIER_REPORT] summary.md
+
+When you are done, output exactly one of these markers as the very last line:
+- Success: [PALMIER_TASK_SUCCESS]
+- Failure: [PALMIER_TASK_FAILURE]
+Do not wrap them in code blocks or add text on the same line.
+
+If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]: e.g.
+[PALMIER_PERMISSION] Read | Read file contents from the repository
+[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
+[PALMIER_PERMISSION] Write | Write generated output files`;
+export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
+export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
+export const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";
+export const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
+//# sourceMappingURL=shared-prompt.js.map

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+export declare function agentsCommand(): Promise<void>;
+//# sourceMappingURL=agents.d.ts.map

package/dist/commands/agents.js

@@ -0,0 +1,19 @@
+import { loadConfig, saveConfig } from "../config.js";
+import { detectAgents } from "../agents/agent.js";
+export async function agentsCommand() {
+    const config = loadConfig();
+    console.log("Detecting installed agents...");
+    const agents = await detectAgents();
+    config.agents = agents;
+    saveConfig(config);
+    if (agents.length === 0) {
+        console.log("No agent CLIs detected.");
+    }
+    else {
+        console.log("Detected agents:");
+        for (const a of agents) {
+            console.log(`  ${a.key} — ${a.label}`);
+        }
+    }
+}
+//# sourceMappingURL=agents.js.map

package/dist/commands/info.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Print host connection info for setting up clients.
+ */
+export declare function infoCommand(): Promise<void>;
+//# sourceMappingURL=info.d.ts.map

package/dist/commands/info.js

@@ -0,0 +1,40 @@
+import * as os from "os";
+import { loadConfig } from "../config.js";
+/**
+ * Detect the first non-internal IPv4 address.
+ */
+function detectLanIp() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] ?? []) {
+            if (iface.family === "IPv4" && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return "127.0.0.1";
+}
+/**
+ * Print host connection info for setting up clients.
+ */
+export async function infoCommand() {
+    const config = loadConfig();
+    const mode = config.mode ?? "nats";
+    console.log(`Mode:    ${mode}`);
+    console.log(`Host ID: ${config.hostId}`);
+    if (mode === "lan" || mode === "auto") {
+        const lanIp = detectLanIp();
+        const port = config.directPort ?? 7400;
+        console.log("");
+        console.log("Direct connection info:");
+        console.log(`  Address: ${lanIp}:${port}`);
+        console.log(`  Token:   ${config.directToken}`);
+    }
+    if (mode === "nats" || mode === "auto") {
+        console.log("");
+        console.log("NATS connection info:");
+        console.log(`  URL:   ${config.natsUrl}`);
+        console.log(`  WS:    ${config.natsWsUrl}`);
+    }
+}
+//# sourceMappingURL=info.js.map

package/dist/commands/init.d.ts

@@ -1,8 +1,13 @@
 export interface InitOptions {
-    token: string;
+    server?: string;
+    lan?: boolean;
+    host?: string;
+    port?: number;
 }
 /**
- * Provision this agent by exchanging a base64 provisioning token for permanent credentials.
+ * Provision this host. Two flows:
+ *   - palmier init --lan              → standalone LAN mode, no server needed
+ *   - palmier init --server <url>     → register with server, prompts for nats/auto mode
  */
 export declare function initCommand(options: InitOptions): Promise<void>;
 //# sourceMappingURL=init.d.ts.map