Human-in-the-loop channels - job events outbound (proposed, will_run, failed, waiting_approval) plus inbound actions (approve/reject/run/disable) over configurable connectors (webhook first, then email, then Telegram), so a job can reach an operator who is not on the box
Global jobs overview across agents - replio jobs list --root <dir> fleet scan, a GET /jobs + POST /jobs/<name>/approve|reject|run|disable operator API on replio serve, then a web Control UI, so one view shows which agents run next and with which task
Edge / offline store-and-forward buffering - offline-capable agents with local buffering for unreliable connectivity (enterprise use case)
Immutable agent config - replio serve agents must never be able to change their own configuration, permissions, or tool list (control-plane rule from the use-case reference architecture)
Hash-chained / tamper-evident audit log - additive on session logs (enterprise.md recommendation), hash-chained append or WORM storage
Single-purpose agent fleet with "one agent per process, scoped to a folder" as the headline pattern. README + docs/fleet.md set the niche
Fleet and swarm orchestration as the two layers - fleet: supervisor running many scoped replio serve instances (port allocation, health checks, restart policy, per-agent config generation), swarm: /agent types, auditor agents, generate > check > correct
Community presence - decide on Discord/X channels and fill the README community link slots
Add multiuser capability or queue for API requests (request queue, per-token rate limits)
Add ReadTheDocs documentation
Citations / source attribution - return URL + snippet with every answer
Bookmarks - /bookmark add/remove/list for session pinning
Interactive data analysis - CSV querying, SQL execution, code eval in REPL
Notebook mode - persistent editable cells with run outputs
Hybrid web + local RAG - vector store (FAISS/Weaviate), embeddings, local document search
Command palette / fuzzy search - CTRL-P style history search
Topic-aware ranking - classifier for query intent to weight search results
Naming / positioning decision - "Replio" collides with commercial SaaS products (replio.chat, repliohq.com, replio.eu), kept for now (PyPI + repo claimed), revisit before any promotion push. Candidate free names: pypelio, replcore, replkit
Competitor research - validate USPs against actual peers (OpenClaw, Claude Code, opencode, agentic-infra services) rather than the unrelated SaaS "Replio" products. Comparison notes now live in docs/vs/ and feed the feature backlog (Plan/Build modes, Web Control UI, plugin marketplace, telemetry, binary builds, sharing)
Self-update - replio update (Pi pi update --self analogue)
Standalone binary build - Pi-style release script producing a single executable (contentious for a zero-dep Python package)
Opt-in telemetry contracts - vendor-neutral event schema (OpenCode, Pi @earendil-works/pi-telemetry). Decide whether it fits the no-telemetry stance
Conversation sharing - web-shareable session links (OpenCode /share) or published sessions (Pi pi-share-hf), building on the planned Markdown export
Plugin registry / marketplace - discoverable plugin sharing (OpenClaw ClawHub analogue). PyPI entry-point source is a prerequisite
[ ] Persistent member sessions for recurring teams - job-style warm sessions for recurring teams, one-off runs stay fresh sub_ sessions (sequential run loop + briefs + team memory landed with Engine.run_team)
[ ] Externalize bundled providers - move opencode/opencode-go (and the vendor providers) out of the core into bundled plugins, keeping BaseProvider/OpenAICompatibleProvider, the PROVIDERS dict + detect_provider, and the plugin register_providers hook as the core mechanisms. Needs a base_url hostname-hint mechanism so plugin providers auto-detect in /connect
[ ] Full file_* namespace extension - if file_glob/file_grep prove better with most models, extend the prefix to list_dir/glob/grep (old names stay aliases)
[ ] Tool spec polish - rename grep.glob -> include (alias glob), add examples and prefer-web_fetch guidance to tool descriptions
[ ] Team kit plugin (movable, private) - templates, recipes, and generator for ad hoc types/skills/teams, kept out of the core. Bundled during development, moved out to its own per-customer repo once documented (docs/teamkit.md)
[ ] Template-based team composition - match type/skill templates from the kit library against the request + project description, generate only the deltas, reuse proven artifacts across projects
[ ] Team kit library - tag/store proven teams, types, and skills per stack and customer, importable into new projects without publishing internal know-how
[ ] Plugin contribution hooks - register_types / register_teams / register_skills plugin entry hooks + TypeRegistry.reload(), so the kit ships templates without forking the core
[ ] Mid-run blocking job approval - an ask tool inside a running job pauses the run in place (per-tool-call waiting_approval), notifies via a connector, and resumes the same session when the operator replies. Needs resumable mid-run state, a wait loop inside the run, and the connectors/transport below (deeper than the shipped per-run --require-approval gate)
[ ] Job event hooks - the scheduler emits typed transitions (proposed, approved, will_run, executing, verified, failed, timeout, waiting_approval) to registered services. Channel-agnostic core, first consumers are the connectors and the operator API
[ ] Job connectors - bundled replio-core-webhook (stdlib JSON POST, zero deps, works with n8n/IFTTT/any URL) first. External email (SMTP + polling) and Telegram (urllib long-poll) plugins later, all driving the jobs operator API so operators can react in time
[ ] Jobs operator API - GET /jobs and POST /jobs/<name>/approve|reject|run|disable on replio serve, so clients (web Control UI, connectors, fleet supervisor) can see and act per agent
[ ] Fleet jobs overview - replio jobs list --root <dir> scanning agent worktrees (agent, job, status, next run, task table), then the web Control UI on top
[ ] Interactive delegation focus - REPL jumps in/out of the active sub-agent (request or automatic on delegate), arrows switch between concurrent delegate_* session logs rendered from their own saved logs (opencode-style sub-agent views)
[ ] Agent type directory scan for export/import - read .replio/types/*.md (front-matter types) to import and export types to Markdown, paralleling the sessions Markdown export/import
[ ] Delegation progress in the REPL - live status of which sub-agent is working and its progress mid-run. delegate already surfaces the task and the final result (plus a sub footer via delegate_echo). The next step is a progress channel read out of the sub-engine loop, which the single blocking Engine.chat() does not expose today
[ ] Auto team selection - the lead agent picks types from the registry for a task and delegates in sequence (team orchestration as a user-facing pattern, e.g. "compare with competitors" -> Researcher > Writer > Referencer > Editor, landing with the team kit composition flow)
[ ] Session log full-restructuring (deferred) - restructure messages from flat role-attribute dicts into a typed parts model, borrowing OpenCode's session file structure (.opencode/sessions/ses_*.json). Deferred: the current flat format already reconstructs every conversation element, so this is architectural polish / ecosystem alignment, not a correctness fix. See the detailed spec below. Do NOT migrate existing .replio/sessions/*.json - they are historical and remain readable as-is
Reference - OpenCode stores each turn as {role, messageId, timestamp, parts[]} where parts are typed objects:
Part types: text, thinking, and tool (co-locating id/tool/input/output/is_error/analysis) so a single assistant message holds thinking + answer + each tool step, dropping the separate tool-role messages
_provider_messages() reconstructs the OpenAI payload (assistant.tool_calls + tool-role results) from the parts (engine.py _provider_messages/_clean_messages)
Optional, larger alternative - full turn-level parts + [step-start]/[step-finish] markers aggregating the multi-round tool loop into one assistant message per user turn (larger agent-loop change)
[ ] Thinking visibility - /thinking on + reasoning config documented, per-provider reasoning_content check so reasoning shows in the REPL
[ ] /spawn command - launch a scoped replio serve agent from the REPL (home -> project path), supervise (health/list/stop) and delegate to it (docs/fleet.md)
[ ] Plugin test harness - replio plugins test <name> ships. Bundled plugin suites live next to the plugins (plugins/<name>/tests/, discovered by the core suite). Remaining: external plugins are expected to ship a test suite, and replio plugins test is the runner for them
[ ] Session recall - full-text search across past sessions (grep/index over .replio/sessions/) so an agent can answer from its own history
[ ] Context-aware cross-plugin tool router - virtual tool names (open, search, ...) dispatch per-argument to the matching plugin handler via register_handler(name, match=...) (e.g. open https://... > replio-core-web, open ../... > replio-core-fs), with merged schemas and args-aware policy accessors
[ ] Swarm orchestration - agent cooperation layer (docs/swarm.md): /agent types, auditor agents, generate > check > correct, and team patterns as sub-tasks below
[ ] Grep text index - internal bundled plugin (stdlib) that indexes converted text files for local search, bridging toward the vector store
[ ] Agent folder watcher - internal bundled plugin (stdlib threading + pathlib polling) that detects new files in an agent's folder and triggers their processing (e.g. convert new PDFs on arrival), scoped capability, no deps
[ ] Minimal web Control UI - stdlib http.server page over the existing replio serve JSON API (OpenClaw Control UI analogue). Richer frameworks stay plugin-first
[ ] Externalize the bundled plugins (replio-core-web/fs/exec) into separate versioned repositories - the bundled copies stay the shipped defaults. Global/local plugins of the same name already override them
[ ] docs_search - local grep + DuckDuckGo for documentation lookups
[ ] Workspace sessions - tools write into a scoped --workspace dir, optional --git sync
[ ] Sandboxed exec - namespace/container isolation for run_command (documented, planned for a later version)
[ ] /agent types - interactive type selection/run UX (type registry, sub-engine, and delegate landed. The /agent command itself remains)
[ ] PM/dev/tester team orchestration as a user-facing pattern (the agent types + delegate primitives landed, and it needs the jobs/team-config layer to be a pattern)
[ ] Headless web API plugin-first - stdlib http.server fallback, richer framework (FastAPI) via the dependency plugin