v0.9.1

Release v0.9.1

Fixes

• Fixed the GitHub release pipeline failing to locate the compiled binary after the amux → awman rename. All build matrix targets now reference the correct awman binary name and produce correctly named release artifacts.

v0.9.0

Release v0.9.0

What changed

v0.9.0 is the first release under the new name: awman — the Agentic Workflow Manager. The tool was previously called amux. This release ships the rename alongside several major features that move the project toward a full software development lifecycle pipeline.

If you are upgrading from 0.8.x, install the new awman binary and run any command. Config is auto-migrated from ~/.amux/ to ~/.awman/ and .amux/ to .awman/ on first run. Old AMUX_* environment variables emit deprecation warnings pointing to their AWMAN_* replacements.

Features

• Rename: amux → awman. The binary, config paths, environment variables, and all documentation now use the awman name. "Headless mode" is renamed to "API mode" everywhere. Auto-migration handles existing config — no manual steps required.

• Workflow setup and teardown. Workflows gain [[setup]] and [[teardown]] sections. Prepare the environment before the first agent step: check out branches, install dependencies, run scripts. After the last step: run tests, commit changes, push branches, open pull requests. All execution happens inside containers — nothing runs on the host. Markdown workflow files are no longer supported; TOML and YAML only.

• Queue-and-worker execution. The API server moves from synchronous request-response to an async job queue backed by SQLite. Submit workflow jobs, and workers pick them up concurrently. Sessions can be local (existing directory) or remote (awman clones a git repo for you). Poll for status via /v1/sessions/{id}/queue.

• Per-step overlays. Each workflow step can define its own overlays array — mount SSH keys, pass environment variables, or attach specific skills to individual steps without leaking resources across step boundaries. Setup and teardown steps also support overlays.

• Unified overlay syntax. ssh() replaces --mount-ssh. env(VAR_NAME) replaces envPassthrough. skill(name) mounts a single named skill; skill(*) mounts all. All overlay types use the same expression syntax everywhere: config files, environment variables, CLI flags, and per-step arrays.

• Antigravity agent. Google Antigravity 2.0 (agy) is now a supported agent. Config and OAuth passthrough, headless mode flags, and skills overlay all work the same as other agents. The gemini agent emits a deprecation warning pointing users to antigravity.

Improvements

• Yolo enhancements. Unified ContainerIo interface across all frontends. Stuck detection moved entirely into the container engine. Full-screen interactive agents work in CLI yolo mode. Auto-detection of missing TTY/PTY with enforcement of --non-interactive. Throttled countdown messages (one per 10 seconds for CLI/API).

• API frontend hardening. The API is restricted to exec workflow and exec prompt only. remote is restructured into concrete subcommands (remote session start, remote exec workflow, etc.). API requests always run in yolo mode. Session creation is async with a setup pipeline. EventBus replaces file-based logging with broadcast channels.

Upgrade path

# 0.8.x → 0.9.0:
curl -s https://prettysmart.dev/install/awman.sh | sh
awman ready

Config migration is automatic. Remove any old amux binary from your PATH. If you have Markdown workflow files, convert them to TOML or YAML — you'll get a clear error message explaining the change. If you use --mount-ssh, switch to --overlay ssh(). If you use envPassthrough in config, move vars to env() overlay expressions.

v0.8.0

Release v0.8.0

What changed

amux's internals have been rebuilt around a strict four-layer architecture. The CLI surface, on-disk state, and TUI behavior are unchanged — every command, flag, alias, and config field works exactly as it did in 0.7.x. The change you will feel is structural: the codebase that backs amux is now organized so each frontend (CLI, TUI, headless) is a thin shell over a shared, tested core, rather than three nearly-parallel implementations.

If you are upgrading from 0.7.x, no migration is required. Open a repo, run amux ready, and continue. Your .amux/config.json, ~/.amux/, persisted workflow state, and the headless server's SQLite database all load unchanged.

Why we did this

After roughly sixty work items of incremental growth, the three frontends had drifted into three subtly different code paths for the same operations. A flag added in one place would not always reach the others; config resolution lived in a tangle of free functions; "just shell out to the CLI" was the headless server's compatibility story. The cumulative effect was that the only way to verify the three frontends produced the same behavior was to run all three by hand and compare. That is not a sustainable engineering posture.

The grand architecture refactor (aspec/architecture/2026-grand-architecture.md) replaces that with four layers and a single hard rule: lower layers may not depend on higher ones. The new shape is:

• Layer 0 — data. Configuration, persistence, on-disk schemas, environment variables. No business logic, no shell-outs, no container calls.
• Layer 1 — engine. Container runtime, workflow engine, git operations, overlays, auth. Real-system primitives the rest of amux composes.
• Layer 2 — command. A single Dispatch type, a typed CommandCatalogue, and one struct per command. All business logic lives here.
• Layer 3 — frontend. CLI, TUI, headless. Each is a presentation shell. They translate user input into Dispatch calls and render outcomes; they do not decide what to do.

The rule is enforced by make architecture-lint, which fails CI on any upward import. If a future feature needs Layer 0 to talk to Layer 1, it does so via a trait that Layer 1 implements — never an upward call.

New feature: skills overlay

v0.8.0 adds one new user-facing feature — the skill() overlay — built as a test of adding features under the new architecture.

Skills created with amux new skill and stored in ~/.amux/skills/ can now be automatically mounted into any agent container as native slash commands. Enable it per-session, per-repo, or globally:

# Per-session
amux chat --overlay "skill()"

# Per-repo (persisted in .amux/config.json)
amux config set overlays.skills true

# Globally
amux config set --global overlays.skills true

# Via environment variable
export AMUX_OVERLAYS="skill()"

amux resolves the correct container path for each agent automatically — Claude Code's ~/.claude/commands/, Codex's ~/.codex/skills/, Gemini's ~/.gemini/commands/, and so on. The mount is always read-only.

Skills overlay can be combined with directory overlays in a single --overlay flag:

amux chat --overlay "skill(),dir(/data/reference:/mnt/reference:ro)"

See Security & Isolation and Configuration for full details.

What you will notice

• amux --help and every subcommand's help text are unchanged.
• amux config show / get / set continue to behave as before.
• .amux/config.json schemas are unchanged. Repos initialised with an earlier amux release continue to work.
• The headless server's HTTP routes, SSE event shape, and SQLite schema are unchanged. Existing ~/.amux/headless/amux.db files load.
• Workflow files (.md, .toml, .yaml) parse identically.

If you spot a behavior that differs from 0.7.x, please file an issue — that is a regression, not a deliberate change.

What changed for contributors

If you are working on amux itself, the new layout will feel different:

• Pre-refactor: src/runtime/, src/tui/, src/commands/ (three roughly-parallel trees).
• Post-refactor: src/data/, src/engine/, src/command/, src/frontend/{cli,tui,headless}/.

Recommended starting points:

• docs/10-architecture-overview.md — user-friendly tour of the four layers.
• aspec/architecture/2026-grand-architecture.md — the full specification.
• aspec/uxui/cli.md — the CLI surface, regenerated from CommandCatalogue.
• make pre-push — the local gate (architecture-lint + fmt + clippy + tests).

Adding a new command now follows a single recipe: register it in CommandCatalogue, implement a Command struct in src/command/commands/, and add the per-frontend trait impls under src/frontend/{cli,tui,headless}/per_command/. The dispatch layer wires it through automatically.

Testing

make test-fast runs in seconds (hermetic). make test-full adds real-Docker, real-git, and live-network suites. CI now runs three jobs per push: a fast lint+fmt+clippy+test pass, a full Docker pass on Linux, and a release-build smoke on macOS. See aspec/devops/cicd.md.

The new test tree (tests/) is medium-coverage: catalogue completeness, real-git worktree cycles, real-Docker runtime checks, a live headless router on an ephemeral port, workflow-state forward-compat against a captured fixture. Deeper coverage — vt100-driven TUI parity, full container lifecycle assertions, captured legacy SQLite fixtures, SSE byte-for-byte fixtures — is tracked in aspec/work-items/0076-deferred-parity-and-e2e-tests.md for a follow-up release.

Acknowledgements

This refactor was specified entirely in advance, then executed across eight work items (WIs 0066–0073) by code agents driven against the spec. The "berating manifesto" tone of the architecture document — the part that says, in effect, do this and only this — turned out to be more important than the code generation itself. See the 0008-grand-refactor.md blog post for the longer version of that story.

Upgrade path

# 0.7.x → 0.8.0:
make install
amux ready
# That's it.

If anything goes wrong: keep your old ~/.amux/ and .amux/config.json — they continue to work with 0.7.x — and report the regression.

v0.7.0

Release v0.7.0

Features

• Headless mode (preview): amux headless start launches an HTTP server that exposes session management and command execution to remote clients — no TUI, no terminal required. Use it to drive amux from CI pipelines, scripts, or remote tooling via a simple REST API.

  • amux headless start [--port <n>] [--background] — start the server; --background daemonizes it via the OS process manager (systemd on Linux, launchd on macOS). Generates an API key on first run.
  • amux headless status — show whether the server is running, its PID, port, active sessions, and uptime.
  • amux headless kill — stop the background server.
  • amux headless logs — stream the server log file in real time (tail -f style).
  • Sessions are named workspaces: POST /v1/sessions creates one, POST /v1/commands dispatches a subcommand to it. Commands execute inside containers with the same isolation as local TUI sessions. All requests, sessions, commands, and their stdout/stderr are stored durably in ~/.amux/headless/.
  • Working directories are allowlisted at startup via --workdirs or headless.workDirs in global config. Any session request for a directory not on the list is rejected with HTTP 403.
  • API key authentication required on all endpoints (generated once, refreshable with --refresh-key).

• Remote mode (preview): amux remote connects to a running headless server and manages sessions and commands from your local machine or TUI.

  • amux remote run <command> [--session <id>] [--follow] — dispatch a command to a remote session. --follow streams logs until the command completes, then prints a summary table.
  • amux remote session start <dir> — create a new session on the remote host.
  • amux remote session kill <id> — close a session on the remote host.
  • In TUI mode, omitting --session shows an interactive session picker; the last-used session per tab is remembered.
  • remote.defaultAddr and remote.savedDirs config keys let you skip the --remote-addr flag on every invocation.

• amux exec subcommand: Cleaner entry points for one-shot agent tasks and workflow runs, designed for scripting and CI.

  • amux exec prompt "<text>" [flags] — launch an agent with the given prompt pre-supplied, without dropping into a blank interactive session. Shares all flags with chat.
  • amux exec workflow <path> [--work-item <N>] [flags] (alias: exec wf) — run a workflow file directly, with an optional work item for template substitution. Equivalent to implement --workflow but does not require a work item number.
  • -n is now a short alias for --non-interactive on all commands that support it.

• TOML and YAML workflow files: Workflow files no longer have to be Markdown. Pass a .toml or .yaml/.yml file to --workflow (or exec workflow) and amux parses it using the same data model. Format is detected by file extension; the Markdown parser is unchanged.

• Model selection: Pass --model <name> to chat or implement to override the LLM model for that session. In workflow files, add Model: <name> to any step header to target a specific model per step. The --model flag acts as the default for steps that do not specify their own model; a step-level Model: always wins.

Improvements

• TUI keyboard shortcuts:

  • Ctrl-W opens the workflow control board regardless of whether the container window is maximized or minimized — no more needing to minimize first.
  • Ctrl-M toggles the container window between maximized and minimized. Esc is now forwarded to the agent as \x1b when the window is maximized, which means vim, fzf, and other interactive programs inside the container work correctly.
  • Ctrl-, opens the config dialog from anywhere in the TUI — even while an agent is running or the container window is maximized.
  • Bare c no longer restores the container window (use Ctrl-M instead).

• headless.alwaysNonInteractive config: Set headless.alwaysNonInteractive: true in global config to force --non-interactive on all commands dispatched through the headless server, preventing any command from blocking on TTY input.

• ready --json: Pass --json to amux ready for machine-readable output. Returns a structured JSON object with the status of each check — useful in CI or when scripting environment verification.

Fixes

• Fixed flag_parser::parse_flags receiving the full command token slice in remote TUI handlers instead of the post-command subslice.
• Fixed RemoteSessionChosen action not eagerly updating last_remote_session_id before launch_pending_command.

v0.6.0

Release v0.6.0

Features

• Multi-agent chat and workflows: Pass --agent <name> to chat or implement to run that session in a different agent's container without changing your repo config. In workflow files, add Agent: <name> to any step header to run that step in a specific agent — enabling pipelines where, for example, Claude plans and Codex implements. Before the first step runs, amux collects every distinct agent name required, checks that the corresponding image exists, and offers to download and build any that are missing. An --agent flag at the command line sets the default for steps that do not name an agent; it does not override steps that explicitly specify one. Both --flag value and --flag=value forms are accepted in both the CLI and the TUI command box.

• amux config subcommand: View and edit configuration without manually opening JSON files.

  • amux config show — renders every config field across global and repo scopes in a table, including built-in defaults for unset fields and an override indicator when the repo value shadows the global value.
  • amux config get <field> — shows global value, repo value, and effective value for one field, with an explicit note about which scope wins.
  • amux config set [--global] <field> <value> — writes a value at the repo or global scope, with scope enforcement (e.g. runtime is global-only, agent is repo-only) and warnings when the new value will be shadowed by an override at the other scope.
  • The TUI gains a live config table: type config show in the command box to open it.

• Configurable work item paths: amux is no longer tied to the aspec/work-items/ directory layout. Set work_items.dir and work_items.template in repo config to point specs new and implement at any directory in your project.

  • Template auto-discovery: if no template is configured, specs new scans the work items directory for *template.md files and prompts to save the match so you won't be asked again.
  • amux init offers to configure a custom work items directory interactively when aspec/ doesn't exist.
  • amux ready shows a warning (not an error) when no work items directory is configured and prints the config set command to fix it.
  • Paths are validated to stay within the git root.

• Background yolo countdown: When a background tab's yolo-mode workflow step goes silent, the tab bar shows a live countdown without requiring you to switch to that tab. The tab alternates between yellow and purple every second, cycling ⚠️ yolo in N and 🤘 yolo in N. When the timer expires, the workflow auto-advances without any input. Switching to the tab mid-countdown opens the yolo dialog showing the time remaining — the timer is not reset. Pressing Ctrl+A or Ctrl+D while the dialog is open closes it and keeps the countdown running in the background.

• Active-tab stuck suppression: On the currently active tab, the stuck timer and yolo countdown dialog will not fire while you are actively pressing keys or scrolling. Both the container and the user must be idle for 10 seconds before a stuck state is declared. Background tabs are unaffected and continue using output-time only.

Improvements

• Modular Dockerfiles: Agent setup is split into a project base image (Dockerfile.dev) and per-agent images (.amux/Dockerfile.{agent} in the .amux/ directory). The project base contains only project tooling; agent images extend it with the AI agent binary. Updating your project toolchain no longer requires rebuilding agent images, and adding a new agent doesn't force a full base rebuild.

• CLI/TUI flag unification: All command flags are now defined in a single CommandSpec table that both the CLI parser and the TUI input system are compiled against. Adding a new flag in one place automatically propagates to both surfaces, TUI autocomplete, and tests. Both --flag value and --flag=value forms are accepted identically everywhere.

• init and ready now share a unified execute()/flow trait, reducing duplication and ensuring new steps appear consistently across both commands.

Fixes

• Fixed workflow control board not allowing the "advance to next step" action when the next step uses a different agent than the current step.

v0.5.0

Release v0.5.0

Features

• Multiple container runtimes: amux now abstracts all container operations behind an AgentRuntime trait. Docker remains the default; Apple Containers (container CLI, macOS 26+) is available as a second runtime — no Docker Desktop required on macOS.

  • Set "runtime": "apple-containers" in ~/.amux/config.json to switch. All amux operations map to the equivalent container CLI invocations.
  • amux ready validates the configured runtime and prints which is active before any other checks.
  • --allow-docker and amux claws are Docker-only; using them with the Apple Containers runtime produces a clear error rather than silent failure.
  • New runtimes can be added by implementing the AgentRuntime trait — no changes to the TUI, command handlers, or auth paths needed.

• Yolo mode (--yolo): Fully autonomous agent operation. Pass --yolo to chat or implement to skip all agent permission prompts.

  • Agent-specific skip-permissions flags: --dangerously-skip-permissions (Claude), --full-auto (Codex), --yolo (Maki, Gemini).
  • When combined with --workflow, automatically creates an isolated Git worktree — no --worktree flag needed.
  • Yolo countdown dialog: when a workflow step agent gets stuck (indicating it's done, since it's in yolo mode), a 60-second countdown opens in the TUI and automatically advances to the next step when it expires. Any new output from the agent cancels the countdown.
  • yoloDisallowedTools config field (per-repo and global) restricts which tools the agent may use even under --yolo. Per-repo config replaces the global list entirely.

• --auto mode: Intermediate autonomy — the agent auto-approves file edits and writes but still prompts before shell commands and other high-risk operations. Less permissive than --yolo.

  • Flag mappings: --permission-mode auto (Claude), --full-auto (Codex), --yolo (Maki), --approval-mode=auto_edit (Gemini).
  • Combined with --workflow, implies --worktree but does not activate the yolo countdown.
  • When both --yolo and --auto are passed, --yolo wins.

• Maki support: maki is now an experimental agent alongside Claude, Codex, and OpenCode.

  • amux init --agent maki downloads Dockerfile.maki and sets up the repo.
  • --yolo maps to maki's native --yolo flag. Plan mode is silently skipped (no equivalent).
  • Maki authenticates via API keys. Use envPassthrough to inject them.

• Google Gemini CLI support: Gemini CLI is now a first-class agent.

  • amux init --agent gemini downloads Dockerfile.gemini (Node.js 20 + @google/gemini-cli).
  • --plan maps to --approval-mode=plan; --auto maps to --approval-mode=auto_edit; --yolo maps to gemini's native --yolo.
  • Two auth paths: API key via envPassthrough (GEMINI_API_KEY, Vertex AI vars), and automatic ~/.gemini/ OAuth mount (copied to a temp dir, same pattern as Claude settings).

• envPassthrough config field: An allowlist of host environment variable names that amux reads from the current shell and injects into any agent container at launch. Applies to all agents; primary auth mechanism for Maki and Gemini.

  • Per-repo config replaces the global list entirely (not merged).
  • Variables absent from the shell are silently skipped.
  • Values are masked (***) in all displayed docker run / container run commands.

• Workflow control board — snooze key (d): Press d in the workflow control board to disable the auto-popup for the current workflow step. The control board remains accessible via Ctrl+W at any time; it simply will not re-open automatically until the step advances.

Improvements

• The Docker code path has been refactored into DockerRuntime implementing the AgentRuntime trait. All call sites in commands and the TUI now receive the runtime via dependency injection — no direct calls to docker::* functions remain outside the runtime layer. Utility functions (generate_container_name, project_image_tag, parse_cpu_percent, parse_memory_mb) are free functions independent of the runtime.

Fixes

• Fixed displayed build and run command strings not reflecting the configured runtime CLI binary (e.g. showing docker even when container was active).
• Fixed various build warnings introduced during the runtime refactor.
• Fixed aspec download link.

v0.4.1

Release v0.4.1

Features

• Terminal text selection and copy: Select text in the container window by
  clicking and dragging the mouse. The selected region is highlighted with
  inverted colours. Press Ctrl+Y to copy the selection to the system
  clipboard as plain text (ANSI colour codes are stripped). Ctrl+Y with no
  active selection forwards the key to the agent as normal. Selection is
  automatically cleared on Esc, terminal resize, or when a new container
  session starts.

• Expanded scrollback history (10,000 lines): The container terminal now
  retains up to 10,000 lines of scrollback history by default (up from the
  previous ~50-line effective limit). The scroll speed increases to 5 lines per
  mouse-wheel tick. The scrollback indicator in the title bar now shows
  ↑ scrollback (N / M lines) — the current offset N and the total depth M
  — so you can see at a glance how far back you have scrolled and how much
  history is available.

• Configurable scrollback line count: The scrollback capacity can be tuned
  per-repository or globally via a new terminal_scrollback_lines config field.
  Per-repo config takes precedence over global config; both fall back to the
  built-in default of 10,000 lines. Reduce this value to lower memory usage
  when running many tabs; increase it for very long build or test runs.

  Per-repo (GITROOT/.amux/config.json):

  { "terminal_scrollback_lines": 5000 }

  Global ($HOME/.amux/config.json):

  { "terminal_scrollback_lines": 20000 }

Improvements

• Scrollback depth probe: The scroll handler now probes the actual number of
  retained scrollback rows (via a set_scrollback(usize::MAX) sentinel) instead
  of capping at the visible screen height. This was the root cause of the
  previous ~50-line limit — the parser held 1,000 rows but the scroll offset was
  incorrectly bounded to the ~24-row screen size.

• Clipboard abstraction for CI: The clipboard write path is abstracted
  behind a ClipboardWriter trait, making the copy flow testable without a real
  display server. In headless environments (no X11/Wayland), clipboard
  initialisation fails gracefully with a log warning instead of a panic.

Fixes

• Fixed the container terminal scrollback being limited to approximately one
  screen height regardless of how much history was stored in the parser.

v0.4.0

Release v0.4.0

Features

• Multi-step workflows (--workflow): Define a sequence of agent runs in a plain Markdown file and execute them as a DAG with amux implement <NNNN> --workflow <path>. amux parses the file into a dependency graph, runs each step inside a container, and pauses between steps for your review. State is persisted so interrupted workflows can be resumed.

  • Prompt templates let steps reference the work item number, full content, or individual sections ({{work_item_content}}, {{work_item_section:[Name]}}).
  • Parallel step groups (multiple steps with the same dependency) are sequenced automatically.

• Worktree isolation (--worktree): Run an agent against an isolated Git worktree under ~/.amux/worktrees/<repo>/<NNNN>/ instead of your main working tree. After the agent finishes, choose to merge, discard, or keep the branch — all from a TUI dialog.

  • Works with --workflow: every step in the workflow operates in the same isolated worktree.
  • Existing worktrees are detected on re-run; you can resume or start fresh.

• SSH credentials mount (--mount-ssh): Pass --mount-ssh alongside any session command to give the agent container access to your host SSH keys. Useful for cloning private repos or pushing branches from within the container.

• Workflow control board (Ctrl+W): While a workflow step is running (container minimized), press Ctrl+W to open the workflow control board — a popup that lets you advance to the next step, restart the current step, skip it, or cancel the workflow without waiting for the current step to finish.

  • Auto-opens when a workflow step produces no output for 10 seconds (stuck detection), so you can act immediately without noticing the yellow tab indicator.
  • Deferred for background tabs: if the stuck step is not the active tab, the control board opens the moment you switch to it.

Improvements

• Workflow control board cooldown: After dismissing the auto-advance dialog with Esc, it will not reappear for 60 seconds for the same stuck episode. This prevents the dialog from re-opening on every render tick while you're actively watching a slow step.

• Commit signing (GPG, SSH, S/MIME): When commit.gpgsign = true or a signing format is configured, amux now suspends the TUI before any git commit it runs in the worktree merge flow, allowing your passphrase prompt (pinentry, ssh-askpass, etc.) to appear and operate normally. The TUI is restored immediately after the command returns, even if it fails.

Fixes

• Fixed flaky tests in the stuck-detection and workflow state machinery.
• Fixed a cargo build warning introduced during the workflow implementation.
• Fixed LSP message suppression in the agent container output.

v0.3.0

Release v0.3.0

Features

• amux specs subcommand group: Spec-related commands are now unified under amux specs:
  • amux specs new [--interview] — Create a new work item. Pass --interview to have the agent help you complete the spec interactively after the file is created.
  • amux specs amend <NNNN> — After implementing a work item, run this to have the agent review the implementation and update the spec to match what was actually built.
• --interview flag: Combines work item creation with an agent-assisted spec completion session. After amux specs new --interview creates the file, the agent opens an interview window where it asks questions and fills in the spec based on your answers.
• New Enhancement work item type: amux specs new now offers Feature, Bug, Task, and Enhancement as work item kinds.
• amux status [--watch]: A live dashboard showing all running containers — code agent sessions and the nanoclaw container. Displays CPU usage, memory, project paths, and agent names. Run once for a snapshot, or pass --watch for a continuously refreshing view (3-second intervals).

Improvements

• Active tab visual distinction: The active TUI tab now has its bottom border suppressed, making it appear to open directly into the content area. Much easier to tell at a glance which tab you're on.
• Improved quit and close-tab behaviour: Closing a tab or quitting amux while containers are running now behaves more predictably, with cleaner state transitions.

Fixes

• Fixed the interview window layout when the container window is open.
• Fixed ready summary table rendering in some terminal configurations.

v0.2.0

Release v0.2.0

Features

• Multi-agent TUI tabs: Run multiple agents in parallel from the TUI. Each agent gets its own tab; switch between them with keyboard shortcuts.
• Stuck tab detection: The TUI now detects when an agent appears stuck and surfaces a warning so you can intervene.
• nanoclaw support (amux claws): New claws subcommands for managing persistent nanoclaw agent containers:
  • claws init — First-time setup: fork/clone nanoclaw, build the image, and launch the container
  • claws ready — Check whether the nanoclaw container is running; offers to start it if stopped
  • claws chat — Attach to a running nanoclaw container for a freeform chat session
• --allow-docker flag: Pass --allow-docker to implement, chat, or in TUI mode to give agent containers access to the host Docker daemon — useful when your work item involves building or running containers.
• Improved init and ready commands: More robust environment detection, clearer prompts, and better error messages during first-time setup.

Fixes

• Fixed working directory issues when running subcommands from TUI tabs — commands now correctly use the repo root.
• Fixed tab state getting out of sync when containers exited unexpectedly.