Delegate computer use from Amp to Codex via Herdr

Set up this Mac so my Amp agents in orbs can hand it browser and desktop tasks.

I've added the delegating-computer-use skill (SKILL.⁠md and config.json). Read it first.

Steps
1. Check Amp is installed and signed in, in the macOS account I use for the desktop.
2. Keep an Amp runner running with a user LaunchAgent that starts at login and restarts it if it stops. I use `amp --no-tui --runner-id <id> --remote-control-terminal --log-file <path>`. Check `amp --help` for the flags on this version.
3. Install Herdr (herdr.⁠⁠dev) and save its agent skill (`herdr --skill`) to a file. Create a dedicated Herdr session and workspace for the GUI worker with one shell pane. Don't touch my normal terminal panes.
4. Check Codex is installed, signed in and can use computer use.
5. Fill in config.json with the runner ID, working directory, Herdr session, workspace label, worker name, lock directory and Herdr skill path. Keep the model, reasoning effort and launch args unless I say otherwise.
6. Stop and tell me if something needs a password, a macOS permission prompt or a setting only I can change.
7. Give me a harmless read-only test I can send from an Amp orb thread, like opening example.⁠com in Chrome and reporting the page title.```

SKILL.⁠md

````markdown
---
name: delegating-computer-use
description: "Runs signed-in browser and native desktop tasks through a temporary high-mode Amp runner thread and a fresh Herdr Codex worker. Use when an Orb needs the user's local sessions or native GUI tools."
---

# Delegate computer use

Read bundled [config.json](config.json).
Use the configured runner for local sessions and native GUI tasks. If unavailable,
report the blocker. Never silently fall back to Orb Desktop or another runner/session.

## From an Orb

1. Call `list_runners` once; confirm `runner_id` is online and serves `working_directory`.
2. Create one temporary thread with `executor: "runner"`, configured `runner_id`
and `working_directory`, `agent_mode: "high"`, and `intent: "environment-access"`.
Omit `archive_when_done`. Tell it to load this skill, do the work itself,
and create no further threads.
3. Include a stable request ID, this thread's reply URL, the task, authorization
limits, and safe evidence needed. Require replies via `send_thread_message`;
do not also use `wait_for_threads`. Save the returned runner thread URL.
4. Send all follow-ups, including completed human handoffs, to that same thread.
Do not replace a blocked worker or replay an uncertain action.

Already on the configured runner for this request? Execute the steps below directly.
Only a temporary task thread may archive itself, never the originating project thread.

## On the runner

Read `herdr_skill_path` and its worker reference. Use only the configured dedicated
Herdr session/workspace (never an empty/default session) and live pane IDs.
Only one GUI worker may run at a time.

1. Create the lock's parent if needed, then atomically claim `owner_lock_directory`
with `mkdir`. On failure, report the conflict without touching the worker or lock.
Never steal a live lock. Empty or old locks are not proof of abandonment;
dead-owner recovery needs explicit approval and confirmation the owner cannot resume.
2. Write `owner.⁠md` inside the claimed lock: unique ownership token, request ID,
owner/reply thread URLs, scope, and action state. Add pane/process identity after launch.
3. Discover and reuse the persistent workspace and shell pane. Create missing resources
with `--no-focus` only if authorized. Require the shell in the foreground and no
existing worker; otherwise retain the lock and report the conflict.
4. Start a fresh interactive Codex process/conversation for each new request.
Use configured model, reasoning effort, and launch arguments; defaults are
GPT-6 Luna high with mandatory `--yolo --no-alt-screen`. Verify actual launch state.
Never substitute safer approval flags, use `exec`/`resume`/`--last`, or start a
second worker after a timeout. `--yolo` does not expand task authorization.

Use these commands with values from config and the discovered pane ID:

```sh
herdr --session <herdr_session> workspace list
herdr --session <herdr_session> pane list --workspace <workspace-id>
herdr --session <herdr_session> pane process-info --pane <pane-id>
herdr --session <herdr_session> agent list
herdr --session <herdr_session> agent start <worker_name> --kind codex --pane <pane-id> -- --model gpt-6-luna -c model_reasoning_effort=high --yolo --no-alt-screen
herdr --session <herdr_session> agent prompt <worker_name> "<task>" --wait --timeout 120000
herdr --session <herdr_session> agent get <worker_name>
herdr --session <herdr_session> agent read <worker_name> --source recent-unwrapped --lines 120
# If still working, wait for the same turn; do not resend it.
herdr --session <herdr_session> agent wait <worker_name> --timeout 120000

herdr --session <herdr_session> agent send-keys <worker_name> ctrl+d
herdr --session <herdr_session> pane process-info --pane <pane-id>
herdr --session <herdr_session> agent list

{
"runner_id": "ian-mac",
"working_directory": "/Users/mac",
"herdr_session": "amp-workers",
"herdr_workspace_label": "amp-workers",
"worker_name": "amp-gui",
"owner_lock_directory": "/Users/mac/.local/state/amp-workers/owner.lock",
"herdr_skill_path": "/Users/mac/.agents/skills/herdr/SKILL.⁠md",
"codex_launch_args": ["--yolo", "--no-alt-screen"],
"model": "gpt-6-luna",
"reasoning_effort": "high"
}