cailmdaley
diff --git a/‎AGENTS.md‎
Lines changed: 41 additions & 47 deletions b/‎AGENTS.md‎
Lines changed: 41 additions & 47 deletions
diff --git a/‎Makefile‎
Lines changed: 15 additions & 28 deletions b/‎Makefile‎
Lines changed: 15 additions & 28 deletions
@@ -82,10 +82,9 @@ make build      # mix escript.build → bin/shuttle (MIX_ENV=dev)
 make start      # nohup detached; logs → ~/Library/Logs/shuttle.log (macOS)
 make stop       # SIGTERM with 5s grace
 make restart    # build + stop + start (the load-bearing daemon target)
-make cli        # go build → ~/go/bin/shuttle-ctl (load-bearing CLI target)
-make all        # restart + cli (everything)
+make all        # restart (daemon)
 make logs       # tail -f the log
-make status     # shuttle-ctl ps + snapshot summary
+make status     # felt shuttle ps + snapshot summary
 make clean      # rm _build and stray Elixir.*.beam at project root
 
 make install-agent    # durable launchd keep-alive (crash + login restart)
@@ -284,10 +283,10 @@ node via a `bash -lc` login-shell fallback, so it works even though the respawn
 loop sources asdf but not nvm. A host without node/MySTRA fails `/astra` cleanly;
 the board + fibers are unaffected.
 
-**Two artifacts, two languages, two release cadences.** The Elixir daemon
-(`bin/shuttle`) and the Go CLI (`~/go/bin/shuttle-ctl`) are independent —
-rebuilding one never implies rebuilding the other. Editing `cmd/shuttle/*.go`
-needs `make cli`; editing `lib/shuttle/*.ex` needs `make restart`.
+**One artifact in this repo: the Elixir daemon.** `bin/shuttle` is the only
+buildable thing here — editing `lib/shuttle/*.ex` needs `make restart`. The
+agent-facing CLI is `felt shuttle <verb>`, owned and shipped by felt (the old
+standalone shuttle-ctl Go shim is retired); nothing in this repo builds it.
 
 **`bin/shuttle` is an escript** — it bundles BEAM bytecode at build time and
 loads it at boot. A restart without `make build` is a no-op for picking up
@@ -313,24 +312,24 @@ should never be committed.
 bin/shuttle snapshot                          # JSON snapshot of daemon state
 bin/shuttle dispatch <fiber-id>               # one-shot dispatch
 
-# shuttle-ctl — agent-facing CLI; offline; schema-validating
-shuttle-ctl status                            # all fibers with shuttle: blocks
-shuttle-ctl status --all                      # local + every configured remote
-shuttle-ctl status --remote <name>            # single remote
-shuttle-ctl ps                                # live tmux workers only
-shuttle-ctl install <fiber> --project-dir "$PWD" [-m <agent-id>] [--disabled]
-shuttle-ctl repeat <fiber> --schedule "0 9 * * 1-5" --tz Europe/Paris --project-dir "$PWD"
-shuttle-ctl pause <fiber>                       # disable + kill live worker; --no-kill preserves it
-shuttle-ctl resume / accept <fiber>
-shuttle-ctl set-model <fiber> <agent-id>
-shuttle-ctl dispatch <fiber>
-shuttle-ctl handoff <fiber>                     # worker's clean-exit ritual: stamp
+# felt shuttle — agent-facing CLI; offline; schema-validating
+felt shuttle status                            # all fibers with shuttle: blocks
+felt shuttle status --all                      # local + every configured remote
+felt shuttle status --remote <name>            # single remote
+felt shuttle ps                                # live tmux workers only
+felt shuttle install <fiber> --project-dir "$PWD" [-m <agent-id>] [--disabled]
+felt shuttle repeat <fiber> --schedule "0 9 * * 1-5" --tz Europe/Paris --project-dir "$PWD"
+felt shuttle pause <fiber>                       # disable + kill live worker; --no-kill preserves it
+felt shuttle resume / accept <fiber>
+felt shuttle set-model <fiber> <agent-id>
+felt shuttle dispatch <fiber>
+felt shuttle handoff <fiber>                     # worker's clean-exit ritual: stamp
                                                 #   shuttle.handed_off_at (→ next dispatch
                                                 #   is fresh) + end own tmux session. The
                                                 #   single final action; folds in kill $PPID.
-shuttle-ctl snapshot
-shuttle-ctl abort / attach <fiber>
-shuttle-ctl validate-identity                # UID migration/cross-city validation
+felt shuttle snapshot
+felt shuttle abort / attach <fiber>
+felt shuttle validate-identity                # UID migration/cross-city validation
 ```
 
 ## Critical invariants
@@ -355,27 +354,27 @@ shuttle-ctl validate-identity                # UID migration/cross-city validati
   mirror", because the read was attempted locally instead of being owner-routed.
   New endpoints that surface a fiber's host-local content MUST route through
   `OriginRouter`, not assume the bytes are reachable on this host.
-- **Agent records live in one source of truth: `share/agents.json`.** Both
-  runtimes (Elixir daemon, Go CLI) embed it at compile time — Elixir via
-  `@external_resource` + `File.read!` in `lib/shuttle/agents.ex`, Go via
-  `//go:embed` (generated `pkg/schema/agents_embedded.go`). Edit the JSON,
-  then `make restart`. There is no `config/agents.exs`.
+- **Agent records live in one source of truth: felt's registry.** Felt owns
+  the registry for the merge; the daemon reads the already-resolved record off
+  felt's `shuttle.resolved.agent` JSON and shells `felt shuttle agents
+  [resolve]` for the registry / no-fiber cases. There is no daemon-embedded
+  `share/agents.json` and no `config/agents.exs`.
 - **`shuttle.agent` field drives agent selection.** The `shuttle:` block's
   `agent:` field resolves against the registry. Default agent is
   `claude-sonnet`.
 - **`shuttle.host` field drives daemon affinity — strictly.** A daemon
   dispatches a block iff `block.host == own_host_id` (its `SHUTTLE_HOST` or
   `:inet.gethostname()`). There is no `"local"` default and no `nil`
   wildcard: an absent or empty `host:` is unowned and ineligible on *every*
-  daemon. `shuttle-ctl install`/`repeat` stamp `host` by default so blocks
+  daemon. `felt shuttle install`/`repeat` stamp `host` by default so blocks
   are born owned. The same predicate gates the orphan-resurrection path, so
   a remote restart can't re-grab another host's fiber.
-- **`shuttle.project_dir` is required for enabled installs.** `shuttle-ctl
+- **`shuttle.project_dir` is required for enabled installs.** `felt shuttle
   install` and `repeat` require `--project-dir`; workers start there instead
   of falling back to the felt store.
-- **shuttle-ctl is the agent-facing CLI.** Local write verbs validate before
+- **felt shuttle is the agent-facing CLI.** Local write verbs validate before
   write and work offline. Cross-host writes belong to Portolan's kanban/API
-  surface, not to `shuttle-ctl`. `bin/shuttle` handles daemon lifecycle and
+  surface, not to `felt shuttle`. `bin/shuttle` handles daemon lifecycle and
   dispatch.
 - **No tag predicate for dispatch.** The `shuttle:` block's `enabled: true`
   field is the dispatch signal. Tags are free-form qualitative noticings;
@@ -398,7 +397,7 @@ shuttle-ctl validate-identity                # UID migration/cross-city validati
   Scheduled runs dispatch only when `next_due_at` is due AND `review.state`
   is `scheduled` or `accepted`. Manual dispatch is ad-hoc (`adhoc-...`
   run id) and preserves `next_due_at`; worker exit flips state to
-  `awaiting`, and `shuttle-ctl accept` advances `next_due_at` only for
+  `awaiting`, and `felt shuttle accept` advances `next_due_at` only for
   scheduled runs.
 
 ## Dispatch prompt structure
@@ -429,23 +428,23 @@ the git log of the constitution.)
 ## Inspecting state
 
 ```bash
-shuttle-ctl status                       # Go walker view (independent of daemon)
+felt shuttle status                      # offline walker view (independent of daemon)
 bin/shuttle snapshot                     # raw JSON snapshot
 make status                              # daemon-side view (ps + snapshot)
 ~/Library/Logs/shuttle.log               # daemon stdout/stderr (macOS)
 tmux ls | grep '^shuttle-'               # live workers
 curl -s http://127.0.0.1:4000/api/v1/agents | jq
 curl -s http://127.0.0.1:4000/api/v1/state | jq
 curl -s http://127.0.0.1:4000/api/v1/state/composite | jq
-shuttle-ctl validate-identity                # checks :4000/:4001/:4002 by default
+felt shuttle validate-identity                # checks :4000/:4001/:4002 by default
 ```
 
 Dispatch sanity ladder:
 
-1. `shuttle-ctl status` shows `enabled: true, idle, oneshot`? → fiber is
-   well-formed and the Go walker sees it.
+1. `felt shuttle status` shows `enabled: true, idle, oneshot`? → fiber is
+   well-formed and the offline walker sees it.
 2. `bin/shuttle snapshot` lists it under `eligible[]`? → daemon dispatched.
-3. shuttle-ctl sees it but daemon doesn't → daemon binary is stale.
+3. `felt shuttle` sees it but daemon doesn't → daemon binary is stale.
    `make restart`.
 4. Daemon sees it but agent never appears → check `share/agents.json` for
    the resolved agent's `cli` and that the wrapper is on `PATH`.
@@ -480,26 +479,21 @@ shuttle/
 ├── lib/                     Elixir source
 │   ├── shuttle/poller.ex    discover + eligibility + retry queue
 │   ├── shuttle/dispatcher.ex  agent resolution, tmux launch
-│   ├── shuttle/agents.ex    agent registry — reads share/agents.json at compile time
 │   └── shuttle_web/         agent-API HTTP endpoints (/api/v1/...)
-├── cmd/shuttle/             Go CLI (shuttle-ctl)
-├── pkg/schema/              Go schema package (types, validation, YAML I/O)
-│   ├── agents.go            registry loader (//go:embed agents_embedded.go)
-│   └── agents_embedded.go   generated — embeds share/agents.json bytes
-├── share/                   shared data (canonical for both runtimes)
-│   ├── agents.json          THE agent registry — single source of truth
-│   └── schema.json          shuttle: block frontmatter schema
+├── share/                   shared data (plist template, launchd assets)
 ├── config/                  Elixir env config (dev/test/prod endpoint settings)
 ├── test/                    Mix test suite
 └── deps/, _build/           Mix-managed; gitignored
 ```
 
+The agent-facing CLI (`felt shuttle <verb>`) and the agent registry are owned by
+felt, not built here — this repo is pure Elixir + TS.
+
 ## Tests
 
 ```bash
-mix test                   # full Elixir suite (110 tests, ~7s)
+mix test                   # full Elixir suite
 mix test --only focus      # tagged subset
-go test ./pkg/schema/...   # Go schema tests
 
 # Opt-in real harness smoke. Opens real Claude/Codex/Pi CLIs in tmux,
 # sends no prompt, captures the idle pane, then kills the smoke sessions.
 
@@ -1,31 +1,28 @@
-# Shuttle daemon + CLI — build + lifecycle
+# Shuttle daemon — build + lifecycle
 #
-# Two artifacts share this repo:
+# One artifact lives in this repo:
 #   - bin/shuttle  (Elixir escript) — the daemon. Loads BEAMs at boot;
 #     `make restart` rebuilds + bounces.
-#   - shuttle-ctl  (Go binary)      — the agent-facing CLI. Built into
-#     $(CLI_DEST) which sits on PATH; `make cli` rebuilds + installs.
 #
-# `make restart` is the load-bearing daemon target. `make cli` is the
-# load-bearing CLI target — when a new shuttle-ctl verb lands, any
-# tool that shells out to it will silently break with a stale binary.
-# The daemon and CLI are independent (Elixir vs Go), so building one
-# never implies rebuilding the other; `make all` does both.
+# The agent-facing CLI is now `felt shuttle <verb>` — owned by felt, not built
+# here (the old standalone shuttle-ctl Go shim is retired). This repo is pure
+# Elixir + TS; there is nothing to `go build`.
+#
+# `make restart` is the load-bearing daemon target.
 
 LOG := $(HOME)/Library/Logs/shuttle.log
 # Match both the local `bin/shuttle ... -extra bin/shuttle start` shape and
 # remote respawn-loop `./bin/shuttle ... -extra ./bin/shuttle start` shape.
 # `[b]in` prevents pgrep from matching its own shell command.
 PIDPATTERN := [b]in/shuttle -B .* -extra \.?/?bin/shuttle start
-CLI_DEST := $(HOME)/go/bin/shuttle-ctl
 AGENT_LABEL := io.shuttle.daemon
 AGENT_PLIST := $(HOME)/Library/LaunchAgents/$(AGENT_LABEL).plist
 # Felt stores the launchd daemon polls. Defaults to the loom aggregate (~/loom,
 # outside ~/Documents) so the agent touches no TCC-protected path and needs no
 # Full Disk Access. Override to add stores: make install-agent AGENT_LOOM_HOMES=~/loom,/some/other
 AGENT_LOOM_HOMES ?= $(HOME)/loom
 # The daemon's PATH, captured from a login shell at install time so it carries
-# Homebrew (escript/erl), ~/.local/bin (felt), ~/go/bin (shuttle-ctl), etc. —
+# Homebrew (escript/erl) and ~/.local/bin (felt), etc. —
 # launchd's own env is too bare, and sourcing the profile at runtime under
 # launchd doesn't reconstruct it. This is the user's real PATH, frozen.
 AGENT_PATH ?= $(shell /bin/bash -lc 'echo $$PATH')
@@ -36,11 +33,11 @@ AGENT_PATH ?= $(shell /bin/bash -lc 'echo $$PATH')
 # ~/.ssh/agent.sock is the stable login-agent path; override if yours differs.
 AGENT_SSH_AUTH_SOCK ?= $(HOME)/.ssh/agent.sock
 
-.PHONY: all build cli start stop restart logs status clean help install-agent uninstall-agent
+.PHONY: all build start stop restart logs status clean help install-agent uninstall-agent
 
 # Felt owns the agent registry — the single source of truth for the merge. The
-# Go CLI is a thin `exec felt shuttle` shim (cmd/shuttle/main.go); the Elixir
-# daemon no longer embeds a registry either (Stage 4a): it reads the
+# agent-facing CLI is `felt shuttle <verb>` (felt absorbed every verb); the
+# Elixir daemon no longer embeds a registry either (Stage 4a): it reads the
 # already-resolved record off felt's `shuttle.resolved.agent` JSON and shells
 # `felt shuttle agents [resolve]` for the registry / no-fiber cases. The old
 # share/agents.json + pkg/schema's generated agents_embedded.go are gone.
@@ -54,28 +51,18 @@ help:
 	@echo "  make install-agent   — durable launchd keep-alive (crash + login restart)"
 	@echo "  make uninstall-agent — remove the launchd agent"
 	@echo "  make logs     — tail -f the daemon log"
-	@echo "  make status   — shuttle-ctl ps + snapshot summary"
+	@echo "  make status   — felt shuttle ps + snapshot summary"
 	@echo "  make clean    — remove _build and stray .beam files"
 	@echo ""
-	@echo "shuttle-ctl CLI (Go):"
-	@echo "  make cli      — go build → $(CLI_DEST) (must be on PATH)"
-	@echo ""
 	@echo "everything:"
-	@echo "  make all      — restart (daemon) + cli"
+	@echo "  make all      — restart (daemon)"
 
-all: restart cli
+all: restart
 
 build:
 	mix shuttle.gen_version
 	mix escript.build
 
-# Build the Go CLI and install to $(CLI_DEST). `go install ./cmd/shuttle`
-# would output as `shuttle` (matches cobra Use:), so we use `go build -o`
-# to land it under the historical `shuttle-ctl` name.
-cli:
-	@go build -o $(CLI_DEST) ./cmd/shuttle
-	@echo "shuttle-ctl → $(CLI_DEST) (shim: exec felt shuttle)"
-
 start:
 	@if pgrep -f '$(PIDPATTERN)' >/dev/null; then \
 	  echo "shuttle already running (pid $$(pgrep -f '$(PIDPATTERN)'))"; exit 1; \
@@ -138,7 +125,7 @@ logs:
 	@tail -f $(LOG)
 
 status:
-	@shuttle-ctl ps 2>/dev/null || echo "(shuttle-ctl ps unavailable)"
+	@felt shuttle ps 2>/dev/null || echo "(felt shuttle ps unavailable)"
 	@echo
 	@bin/shuttle snapshot 2>/dev/null | python3 -c "import json,sys; o=json.load(sys.stdin); \
 	  print('felt_hosts:', o.get('felt_hosts','MISSING (binary pre-297a24d)')); \