Skip to content

ROADMAP.md

Latest commit

 

History

History
134 lines (107 loc) · 7.89 KB

ROADMAP.md

File metadata and controls

134 lines (107 loc) · 7.89 KB
Raw

Roadmap

Milestones M0–M5, ordered low-risk → high-risk, each independently shippable and demo-able. MVP = M0 + M1 — the point where the real-world claude↔codex review loop (the workflow this tool was born from) runs end-to-end with zero terminal copy-paste. Detailed per-phase implementation plans (harn-style, one plan per commit) are written per milestone when that milestone starts — this file stays the map, not the turf.

M0 — Dial tone

A channel exists; one human and one owned agent talk in it over the tailnet.

  • packages/protocol: schemas for Member/Message/WireEvent/deliveries (PROTOCOL.md → zod).
  • packages/switchboard: SQLite store, run-blob journal, WS/REST API, single-channel MVP of the router (mention→recipients, whole-message payloads, refs, defaults — full PROTOCOL §3 semantics from day one; they're the product).
  • packages/adapters/codex: spawn + resume + deliver via codex exec --json; run message streaming with live header; usage capture.
  • packages/adapters/claude-code: CLI driver — claude -p --resume with stream-json in/out (events, ask-user, and permission prompts over the control protocol → ask/approval cards). No SDK dependency, by design.
  • packages/web: channel timeline, collapsible runs, composer with @/# autocomplete + implied recipient, member rail, ask/approval cards.
  • License + reuse audit (the M0 gate for the build map): verify walkie's license (claude-watch verified MIT → fork cleared; paseo verified AGPL-3.0 → pattern-only, no code reuse); ACP spike — can it carry resume/usage/extensions? Decision recorded in ARCHITECTURE.md.
  • Tailnet deploy recipe (tailscale serve) + pairing token for the web client.

Acceptance: from a browser on another machine (over tailnet), spawn a Codex session and a Claude session into a channel, send @claude plan X, watch the run stream collapse into one message, have Claude's final @codex implement hand off automatically, and read Codex's result — no terminal involvement after setup.

M1 — The party (MVP)

Many sessions, custody in both directions, extensions. The manual review loop is dead.

  • Multi-agent channels: rename, per-member policy chips, queue/batch semantics, member revive.
  • All-harnesses support: Gemini CLI, OpenCode, and Copilot CLI adapters alongside claude/codex (via ACP where the M0 spike cleared it, else direct CLI drivers written against paseo's adapters as behavioral reference). Harnesses not installed on the box are integration-tested against recorded streams; live smoke runs cover whatever is installed.
  • /codor skill (Claude Code) + codor join CLI (Codex): mirrored members, hook-based mirroring, adopt-on-TUI-exit custody transfer.
  • codor attach <member>: jump into any member's session from a terminal via native resume; re-adopt on exit (the reverse custody direction).
  • Extensions: subagent capture via Task-call events + hooks; collapsed rendering under parent.
  • Always-on spend meter; opt-in turn/spend brakes (off by default — agents run to completion); stall flagging.
  • History paging, channel search, message permalinks (#N anchors).

Acceptance: replay a real historical workflow — plan → @codex review (persistent session) → fold findings → @codex re-review → converge — entirely in one channel with no brakes tripping, including one /codor join of a pre-existing live TUI session, one codor attach into a channel-owned member and back, and one subagent appearing as an extension. Separately, a channel with the opt-in turn brake enabled holds and releases correctly.

M2 — Long lines

Channels escape the single machine without touching a cloud.

  • Hyperswarm transport (line:secret → DHT topic; walkie's model): switchboard↔switchboard peering; a channel hosted on the desk reachable from a laptop on hotel wifi.
  • Multi-box channels (ARCHITECTURE §multi-box): remote member residency — deliveries routed to the member's switchboard, events streamed back to the home, unreachable-peer queueing.
  • Channel keys + sealed-box distribution + revocation (PRIVACY §keys) — encryption layered on regardless of transport.
  • Ledger v1 (PROTOCOL §6): vault bootstrap, [[name]] refs resolved into deliveries, codor ledger CLI, change notices in the channel.
  • Optional SQLCipher at rest; multi-device web pairing polish.

Acceptance: two machines with no shared tailnet hold a conversation in one channel over the DHT; a packet capture shows nothing readable; revoking a device locks it out of new messages.

M3 — The pocket web (PWA + push relay)

The web surface becomes the phone app; native apps are demoted to convenience layers.

  • Responsive mobile layout for the SPA; installable PWA (manifest, service worker, offline shell) — on iOS 16.4+ an installed PWA is a home-screen app with notifications, no App Store.
  • Push relay (relay/) built here: sealed-payload forwarding, padded buckets, self-host doc. Web Push (VAPID) to installed PWAs on iOS/Android/desktop; payloads decrypt in the service worker, so the relay and the push service carry ciphertext only.
  • Touch-polished ask/approval cards and composer; browser dictation where the platform offers it.

Acceptance: the M1 acceptance flow driven entirely from a phone's installed PWA over tailnet, including answering an ask card and receiving a sealed push notification — with no native app installed on anything.

M4 — Native glass (iPhone + Apple Watch)

Convenience layers on the same API — the only milestone that needs the Mac. Built in the private apps repo (closed-source, paid one-time — BUSINESS.md); this repo gains only protocol and doc updates.

  • SwiftUI iPhone app: QR pairing, channels, ask/approval sheets, dictation composer; APNs through the same relay, NSE decrypt, keys in Keychain.
  • watchOS app (started from the claude-watch fork): inbox (addressed messages, asks, approvals, brake holds), channel glance, dictation replies with recipient picker; WatchConnectivity via the phone; haptics vocabulary (done / question / hold).

Acceptance: phone app drives the M1 flow end-to-end; then phone in pocket, watch only: receive 🕊️ run-complete, answer an ask card by voice, and hold/release an opt-in turn brake — while no plaintext leaves the tailnet except sealed push payloads.

M5 — Open the doors

From personal tool to open-source project.

  • Adapter SDK: HarnessAdapter documented + reference third-party adapters (ACP-based if the M0 spike held; else OpenCode / Gemini / Copilot CLI direct, with paseo's adapter set as the behavioral reference — reimplemented, never copied, per its AGPL).
  • Multi-human channels as a Relay (paid) feature per the API-key/DB test: org enrollment (invite QR, device-key directory), role enforcement (owner/admin/member/observer), presence, per-human notification routing. The role schema stays in the open protocol.
  • Ledger graph view in the web UI; optional Graphiti indexer for temporal queries.
  • Bridges: Slack + Telegram as opt-in channel mirrors (ARCHITECTURE §bridges) — hosted via the Relay plan (they need platform app credentials), with the bridged banner and role-gated enablement.
  • Self-host guide, threat-model doc review (external eyes invited), docs site, demo video of the M1 acceptance loop, launch.

Acceptance: a stranger with the README, a Mac, and one evening gets tier-0 running with both stock adapters, and a third-party harness lands via the SDK without patching core.

Deliberately deferred

  • Offline ciphertext mailbox (push is a doorbell; content fetch requires reachability).
  • MLS group crypto (sealed-box fan-out is right at ≤5 devices).
  • Addressable extensions, @all, threading beyond reply_to, message editing.
  • Native Android/WearOS (the M3 PWA already covers Android phones; native is someone else's M4).
  • Any hosted "Codor cloud". The moment content touches our servers, PRIVACY.md has failed.