João Salavisa
0b2c59a2dd
* fix(lifecycle): publish AgentReady on wakeup-driven turns Wakeup turns flow Adapter.Prompt → bridge → events, bypassing SessionManager.SendPrompt. The execution status stayed Ready across the wakeup turn, so MarkReady's duplicate-suppression guard dropped the second AgentReady — the orchestrator never closed the turn, never evaluated on_turn_complete, and never dispatched queued messages. Detect this in recordActivity and flip Ready → Running on the first non-terminal event, re-emitting AgentRunning so the rest of the pipeline behaves like any other turn. * fix(lifecycle): gate wakeup flip on turn-content events and handle empty turns Three follow-ups on the wakeup AgentReady fix: 1. Restrict the Ready → Running flip in `recordActivity` to events that unambiguously indicate turn-in-progress activity (message_chunk, reasoning, tool_call/update, plan, agent_plan, permission_request). The original whole-event-type flip caused a regression: claude-agent-acp emits available_commands_update asynchronously ~50ms after session/new, well after dispatchInitialPrompt fires MarkBootReady for a no-prompt task. The Ready → Running flip on that delayed metadata event was putting newly-created tasks back into Running and breaking the chat- input UI (changes-panel-focus E2E tests). 2. Handle the empty-wakeup edge case: a wakeup turn that emits only a `complete` event (empty model response) is still excluded from the flip whitelist, so the Ready guard in MarkReady would suppress AgentReady. `handleCompleteEventMarkState` now publishes AgentReady directly when Status is already Ready on a successful complete — the orchestrator still closes the turn for empty wakeup responses. 3. Fold the `executionStore != nil` check into the early-return so the AgentRunning publish only fires when the status flip actually succeeded. Test-file cleanup from review feedback: dead loop, redundant `var _ = io.MultiReader`, and `teeReader.src any` → `io.Reader`. New regression tests: - TestWakeup_PostBootMetadataEventsDoNotFlipToRunning — locks in the whitelist behavior so future events can't accidentally re-arm a boot-ready session. - TestWakeup_EmptyTurnStillPublishesAgentReady — covers the empty-wakeup-complete fallback. * fix(lifecycle): publish AgentRunning before AgentReady on empty wakeup turns Follow-up on the previous wakeup fixes — addresses three issues raised in review: 1. **Empty-wakeup AgentReady was ignored by the orchestrator.** The fallback in `handleCompleteEventMarkState` published AgentReady when Status was already Ready, but `handleAgentReady` at the orchestrator early-returns when `session.State != Running/Starting`. After the previous turn ended the session is in WaitingForInput, so the AgentReady got silently dropped — same suppression the wakeup fix was meant to prevent. Now the fallback flips Ready → Running + publishes AgentRunning first (mirroring `recordActivity` for the non-empty case), then falls through to MarkReady. 2. **firstActivityOnce could still publish AgentRunning on a late metadata event.** Gate it on `Status != Ready` so a delayed `available_commands_update` arriving after MarkBootReady (the original regression scenario) can't slip through via the once-per-execution path. In practice the adapter always emits `agent_capabilities` during Initialize before MarkBootReady, so firstActivityOnce still fires there with Status==Running — this is defensive hardening. 3. **Tighter test assertions.** The post-boot-metadata test now primes firstActivityOnce in setup and asserts strict `runningCount == 0`. The second-turn test verifies AgentRunning precedes each AgentReady in bus order so the orchestrator's session-state guard isn't violated. Same ordering check added to the empty-wakeup test. * test(lifecycle): rename exec to agentExec to avoid os/exec shadow The test variable `exec` in wakeup_e2e_test.go shadowed the imported `os/exec` package — harmless today because all `exec.Command`/`LookPath` calls happen before the local binding, but a future call added below would silently fail. Rename to `agentExec` to remove the shadow. * ci: retrigger CodeQL after transient Ruby analyze flake The default-setup CodeQL run on PR #875 produced a flaky 'CodeQL could not process any code written in Ruby' failure on the Ruby analyze job (github.com/kdlbs/kandev/actions/runs/26124163769). The repo has no Ruby code and main's CodeQL only analyzes javascript-typescript + actions; the Ruby job was added dynamically and failed on the empty diff. Sibling run 26124163815 on the same SHA passed. Cannot rerun default-setup workflows via the API (403 'cannot be retried'), so push an empty commit to retrigger the analysis. * test(lifecycle): tighten wakeup test assertions - wakeup_simulated_test.go: assert exact readyCount==2 instead of <2 so any over-emission (e.g. duplicate AgentReady on the wakeup turn) is also caught. - wakeup_e2e_test.go: fail with t.Fatalf when the adapter surfaces no WAKEUP text instead of logging a warning. Otherwise the bus-level assertions below pass vacuously if the wakeup never fires. Both fixes address review comments from cubic-dev-ai / claude[bot] on PR #875. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test(lifecycle): remove unsynchronised SessionID write in forwarder goroutine The forwarding goroutine wrote to agentExec.SessionID without holding the executionStore mutex, racing with the main goroutine's authoritative assignment after NewSession returns. The forwarder's write is redundant — line 264 sets the canonical value — and benign in practice, but `go test -race` would flag it. Drop the write to keep the race detector clean. Addresses review comment from claude[bot] on PR #875. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Kandev Agent <agent@kandev.dev> Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
Kandev
Manage and run tasks in parallel. Orchestrate agents. Review changes. Ship value.
Workflows | Run as a Service | Roadmap | Contributing | Architecture | Discord
What
Organize work across kanban and pipeline views with opinionated workflows and execute multiple tasks in parallel. Assign agents from any provider, and review their output in an integrated workspace - file editor, file tree, terminal, browser preview, and git changes in one place. Terminal agent TUIs are great for running agents, but reviewing and iterating on changes there doesn't scale.
Run it locally or self-host it on your own infrastructure and access it from anywhere via Tailscale or any VPN.
Open source, multi-provider, no telemetry, not tied to any cloud.
Vision
Humans stay in control. Define tasks, build agentic workflows with gates, review every change, decide what ships.
- Review-first - Humans support production systems. We need to understand (yet) and trust the code that gets deployed.
- Your workflow - Every team is different, and not every developer uses AI the same way. Define workflows once, share them across the team, and give everyone a consistent process for working with agents - regardless of experience level.
- Remote agents - Running multiple agents on a large codebase can quickly saturate a local machine. The goal is a single control plane: offload execution to servers, orchestrate from anywhere, including your phone.
Features
- Multi-agent support - Claude Code, Codex, GitHub Copilot, Gemini CLI, Amp, Auggie, OpenCode, Cursor, Qwen, Factory Droid, iFlow, Kilocode, Pi, Kimi, AWS Kiro, Qoder, Trae
- Parallel task execution – start and manage multiple tasks from different sources simultaneously, boosting productivity with AI agents
- Integrated workspace - Built-in terminal, code editor with LSP, git changes panel, embedded vscode and chat in one IDE-like view
- Kanban task management - Drag-and-drop boards, columns, and workflow automation
- Agentic workflows - Multi-step pipelines that mix-and-match agents per step - for example, Claude Code Opus to design a plan, GitHub Copilot Sonnet to implement it, and Codex GPT 5.4 to review the changes. See docs/workflows.md
- Sub-tasks - Agents can spawn sub-tasks that resume from the parent task's session. Useful for splitting a task that has grown too big, or producing several PRs from the same starting point.
- CLI passthrough - Drop into raw agent CLI mode for direct terminal interaction with any supported agent, leverage the full power of their TUIs
- Workspace isolation - Git worktrees prevent concurrent agents from conflicting
- Multi-repository tasks - Span a single task across multiple repositories, with one worktree per repo, per-repo branches, per-repo PRs, and per-repo grouping in the Changes panel and review dialog
- Flexible runtimes - Run agents as local processes, in isolated Docker containers or in remote executors like sprites.dev
- Session management - Resume and review agent conversations
- Stats - Track your productivity with stats on the completed tasks, agent turns, etc
Integrations
Connect Kandev to the tools your team already uses — pull issues into the kanban, link tasks to PRs, and surface review activity inline.
Supported ACP Agents
| Agent | Launch |
|---|---|
| Claude Code | npx -y @agentclientprotocol/claude-agent-acp |
| Codex | npx -y @zed-industries/codex-acp |
| GitHub Copilot | npx -y @github/copilot --acp |
| Gemini CLI | npx -y @google/gemini-cli --acp |
| Amp | npx -y amp-acp |
| Auggie | npx -y @augmentcode/auggie --acp |
| OpenCode | opencode acp |
| Cursor | cursor-agent acp (requires Cursor Pro) |
| Qwen | npx -y @qwen-code/qwen-code --acp |
| Factory Droid | npx -y droid exec --output-format acp |
| iFlow (beta) | npx -y @iflow-ai/iflow-cli --experimental-acp |
| Kilocode | npx -y @kilocode/cli acp |
| Pi | npx -y pi-acp |
| Kimi | kimi acp (install Kimi CLI from Moonshot AI) |
| Kiro | kiro-cli-chat acp (install Kiro CLI from AWS) |
| Qoder | qodercli --acp (install Qoder CLI) |
| Trae | traecli acp serve (install Trae IDE CLI) |
All agents communicate via ACP (Agent Client Protocol). Some agents support ACP natively, while others use ACP adapter packages that bridge their native protocols. CLI Passthrough mode is also available for direct terminal interaction with any agent CLI. If your agent isn't supported yet, open an issue or submit a PR with the integration. See Adding a New Agent CLI for a step-by-step guide.
Bring your own TUI agents
There is support for running any agent as TUI inside a terminal. Just add the cli command in the agent profile settings and the task will start the agent inside a PTY terminal instead of using ACP.
Supported Executors
| Executor | Description |
|---|---|
| Local Process | Runs the agent as a local process on the host machine |
| Docker | Runs the agent in an isolated Docker container |
| Sprites | Runs the agent in a remote cloud environment via sprites.dev |
Each executor uses git worktrees for workspace isolation, preventing concurrent agents from conflicting.
Quick Start
Homebrew (macOS, Linux)
brew install kdlbs/kandev/kandev
kandev
NPX
npx kandev@latest
Requires npm 7+. Installs the CLI plus a platform-matched runtime bundle in one step.
NPM (global)
npm install -g kandev@latest
kandev
Updates
brew upgrade kandevnpx kandev@latest(always uses the latest published version)npm install -g kandev@latest
The worktrees and sqlite db live in ~/.kandev by default. Works on macOS, Linux, and Windows (WSL or native).
From Source
# Clone the repository
git clone git@github.com:kdlbs/kandev.git
cd kandev
# Start in production mode
make start
Prerequisites: Go 1.26+, Node.js 18+, pnpm, Docker (optional - needed for container runtimes)
High level architecture
graph LR
UI[Web UI] --> Backend
Backend["Backend (Orchestrator)"]
Backend --> W1 & W2
subgraph W1[Local Process]
Agent1[Agent CLI] --- WT1[Worktree]
end
subgraph W2[Docker Container]
Agent2[Agent CLI] --- WT2[Worktree]
end
We also want to add support for these remote runtimes:
- Remote SSH - run agents on remote servers over SSH, using docker or local processes with workspace isolation
- K8s operator - run agents in a Kubernetes cluster, with auto-scaling and resource management.
Development
Project Structure
apps/
├── backend/ # Go backend (orchestrator, lifecycle, agentctl, WS gateway)
├── web/ # Next.js frontend (SSR, Zustand, real-time subscriptions)
├── cli/ # CLI tool (npx kandev launcher)
└── packages/ # Shared UI components & types
Prerequisites
- Go 1.21+
- Node.js 18+
- pnpm
- Docker (optional)
Running Dev Servers
# Start everything (backend + frontend with auto ports)
make dev
# Or run separately
make dev-backend # Backend on :38429
make dev-web # Frontend on :37429
Testing & Linting
make test # Run all tests (backend + web)
make lint # Run all linters
make typecheck # TypeScript type checking
make fmt # Format all code
Pre-commit Hooks
# Install pre-commit (https://pre-commit.com/#install)
pipx install pre-commit
# Install git hooks
pre-commit install
Comparison to Other Tools
There are a few similar tools in this space, and new ones appearing everyday. Here's what sets this one apart:
- Server-first architecture - Not a desktop app. Runs as a server you can access from any device, including your phone. Start a task away from your computer and check in on it later.
- Remote runtimes - Run agents on remote servers and Docker hosts, not just your local machine.
- Multi-provider - Use Claude Code, Codex, Copilot, Gemini, Amp, Auggie, OpenCode, Cursor, Qwen, Droid, iFlow, Kilocode, Pi, Kimi, Kiro, Qoder, and Trae side by side. Not locked to one vendor.
- CLI passthrough and chat - Interact with agents through structured chat messages or drop into raw CLI mode for full agent TUI capabilities.
- Open source and self-hostable - No vendor lock-in, no telemetry, runs on your infrastructure.
Contributing
Contributions are welcome! Please read CONTRIBUTING.md before opening a PR.
See the issue tracker for open tasks, or join our Discord to chat with maintainers and other contributors.
Acknowledgments
Built with these excellent open-source projects:
Monaco Editor · Tiptap · xterm.js · dockview · CodeMirror · dnd-kit · Mermaid · Recharts · TanStack Table · Zustand · Shadcn/UI · Radix UI · Tailwind CSS