---
name: feno
description: Operate the Feno personal AI mesh across devices (Mac/iPhone/iPad/server) — execute remote shell commands, invoke agents on other nodes, manage ACP sessions cluster-wide, delegate tasks, call remote tools, transfer files, and push notifications to the user's phone.
---

Use the `feno` CLI to drive the Feno mesh cluster. Remote nodes can be phones (iPhone/iPad), computers, or servers. The CLI is the control surface for the mesh — execute shell commands on remote nodes, invoke ACP agents remotely, manage agent sessions cluster-wide, delegate tasks across devices, call any tool registered on any node, and push progress to the user's phone.

All commands output LLM-friendly text (no ANSI colors) when stdout is not a TTY.

## Quick Start

1. Run `feno status` to see connected nodes and their capabilities
2. Run `feno tools list --node <nodeId>` to see what tools a node offers
3. Run `feno tools call --node <nodeId> --tool <tool> --params '<json>'` to invoke a tool

## Cluster Status

```bash
feno status              # Daemon status, peers, watched sessions
feno status -w           # Watch mode (refreshes every 2s)
feno check --node <id>   # Quick reachability check with latency
feno agents              # List registered agents with capabilities
feno setup-status        # Check agent installation state
feno availability        # Node uptime (24h/7d/90d)
```

Always start with `feno status` to understand the current topology before performing other operations.

## Remote Tools

```bash
feno tools list                              # List all remote tools (includes the local node)
feno tools list --node <nodeId>              # Tools on a specific node
feno tools list --describe <tool>            # Full usage and parameter schema
feno tools list --filter <keyword>           # Search by name or description
```

Built-in tools on every node: `exec`, `read`, `write`, `edit`, `list`. Use `--describe` to see a tool's parameters before calling it.

## One-shot Remote Exec

For the common case — "run a shell command on a remote node and get the result" — use `feno exec` directly instead of `tools call`:

```bash
feno exec --node <nodeId> -- ls ~/Desktop
feno exec --node <nodeId> --workdir /tmp -- uname -a
feno exec --node <nodeId> --json -- whoami                  # Emit {stdout,stderr,exitCode}
```

`feno exec` prints stdout to stdout, stderr to stderr, and exits with the remote command's exit code. Use `--json` when you want the full structured result.

## Invoke Tools

```bash
feno tools call --node <nodeId> --tool <tool> --params '<json>'    # Single tool invocation
feno tools batch --node <nodeId> --items '[{"tool":"t1","params":{}},{"tool":"t2","params":{}}]'
```

## Models

```bash
feno models list                # All cluster models
feno models add --provider anthropic --id claude-opus-4-6 --env-var ANTHROPIC_API_KEY
feno models remove --id <modelId>
feno models set --id <modelId> --description "Updated description"
```

## Events

```bash
feno events                        # Unconsumed events
feno events --type <type>          # Filter by type
feno events --source <nodeId>      # Filter by source node
feno events --consume <id1,id2>    # Mark events as consumed
```

## Peer Management

```bash
feno peer list                           # List all peers with connection info
feno peer connect --url ws://192.168.1.100:23512    # Connect to a peer
feno peer disconnect --node <nodeId>     # Disconnect a peer
```

## Peer Approval

```bash
feno approval approve --id <approvalId>    # Approve a pending peer
feno approval deny --id <approvalId>       # Deny a pending peer
feno approval list                         # List pending/approved/denied peers
feno approval revoke --node <nodeId>       # Revoke an approved peer
feno approval undeny --id <nodeId>         # Remove from deny list
```

## Tool Approval

```bash
feno tool-approval pending                           # List pending tool approvals
feno tool-approval resolve --id <id> --decision approve
feno tool-approval rules                             # List approval rules
feno tool-approval add-rule --action allow --tool <name>
feno tool-approval remove-rule --id <ruleId>
```

## ACP Agent Sessions

```bash
feno acp list --node <nodeId>                        # List sessions
feno acp prompt --node <nodeId> -a claude --task "Do something"
feno acp resume --node <nodeId> -a claude --session <id>
feno acp cancel --node <nodeId> --session <id>
feno acp close --node <nodeId> --session <id>
feno acp modes --node <nodeId> --session <id>        # Available modes
feno acp mode --node <nodeId> --session <id> --mode-id <modeId>
feno acp security --node <nodeId> --policy approve-all
feno acp authorize-tool --session <id> --tool-call-id <id> --choice allow
```

## Notifications (Dynamic Island / Live Activity)

Push progress notifications to the user's iPhone via `feno notify`. This triggers the Dynamic Island and lock screen Live Activity.

**Use this proactively when running long tasks** (iOS builds, large refactors, test suites, batch operations) so the user can track progress without watching the terminal.

```bash
# Start a notification
feno notify --title "iOS Build" --detail "Compiling..."

# Update progress
feno notify --title "iOS Build" --action update --task-id <id> --detail "Linking..." --progress 80

# End (success)
feno notify --title "iOS Build" --action end --task-id <id>
```

## Configuration

```bash
feno config show                           # Current config summary
feno config read --path config.json        # Read a config file
feno config write --path config.json --content '<json>'
feno config reload                         # Hot-reload without restart
```

## Audit

```bash
feno audit security                        # Security events
feno audit actions                         # Operation logs
feno audit actions --category tool --limit 20
```

## Workflow

1. Run `feno status` to see the cluster topology
2. Use `feno tools list --filter <keyword>` to find relevant tools
3. Use `feno tools list --describe <tool>` to check parameters
4. Use `feno tools call` or `feno tools batch` to invoke tools
5. If a call fails, run `feno check --node <nodeId>` to verify connectivity
6. For long-running tasks, use `feno notify` to push progress to the user's phone
