clisbot 0.1.11 → 0.1.15

package/README.md

@@ -1,97 +1,44 @@
-# clisbot - Agentic Coding CLI & chat bot
-The cheapest, simplest path to frontier LLMs and agentic CLI workflows for teams and individuals.
+# clisbot - Turn your favorite coding CLI into an agentic assistant and code on the go
+Want to use OpenClaw but are struggling because:
 
-`clisbot` is not just another tmux bridge, as many GitHub projects already are. It exposes native agentic AI tool CLIs like Claude Code / Codex through multi-channel chat surfaces, with each agent running inside its own durable tmux session and ready to behave like a real bot, a real assistant - with SOUL, IDENTITY & MEMORY, just as OpenClaw, not just a coding tool.
+- API cost is too high, so you end up looking for LLM proxy workarounds
+- you have to switch between OpenClaw for daily work and Claude / Codex / Gemini for real coding
+- you want to code on the go and work on the go
 
-`clisbot` is meant to grow into a reusable agent runtime layer that can support many CLI tools, many channels, and many workflow shapes on top of the same durable agent session.
+`clisbot` is the right solution for you.
 
-Agentic AI is powerful, but only with frontier models. OpenClaw took off because people found many ways to access strong frontier models cheaply through subscription-based OAuth. Recent Anthropic enforcement around third-party and proxy-style usage made that risk harder to ignore.
+`clisbot` turns native frontier agent CLIs like Claude Code, Codex, and Gemini CLI into durable Slack and Telegram bots. Each agent runs inside its own tmux session, keeps a real workspace, and can behave like a coding bot, a daily-work assistant, or a team assistant with SOUL, IDENTITY, and MEMORY. It is not just a tmux bridge with chat glued on top. `clisbot` adds channel-aware routing, durable conversation state, pairing and access control, follow-up behavior, and support for sending and receiving files through Slack and Telegram.
 
-Meanwhile, the strongest agentic coding tools already come from serious enterprise teams with real investment in model quality, security, safety, and operator controls, especially Claude Code, Codex, and Gemini CLI. That naturally leads to a simple question: why not reuse those agents as they already are, keep them alive in tmux, and add communication channels, team workflows, and more toys around them?
+It is a cheaper, simpler path to frontier agent workflows for teams and individuals because it reuses the CLI subscriptions you already have instead of forcing a separate API-heavy stack. If you already trust Claude Code, Codex, or Gemini CLI for real work, `clisbot` lets you keep those tools as the core runtime and add chat surfaces, follow-up control, team workflows, and on-the-go access around them.
 
-Every company will likely need an OpenClaw-style strategy over time: a personal agentic assistant for each employee, plus shared agents for each team. `clisbot` starts from a team-first angle, with Slack and shared agent workflows as the default center of gravity instead of treating team collaboration as a later add-on. 
-
-## Important caution
-
-Strong vendor investment in security and safety does not make frontier agentic CLI tools inherently safe. `clisbot` exposes those tools more broadly through chat and workflow surfaces, so you should treat the whole system as high-trust software and use it at your own risk.
-
-## Acknowledgements
-
-`clisbot` would not exist without the ideas, momentum, and practical inspiration created by OpenClaw. Many configuration, routing, and workspace concepts here were learned from studying OpenClaw, then adapted to `clisbot`'s own direction. Respect and thanks to the OpenClaw project and community.
+`clisbot` is also meant to grow into a reusable agent runtime layer that can support many CLI tools, many channels, and many workflow shapes on top of the same durable agent session.
 
 ## Why clisbot
 
-- Reuses the native CLI tools you already know and subscribe to, such as Claude Code, Codex, and Gemini CLI, then extends them across coding, chatbot, and non-dev workflows without forcing you to switch tools.
-- Optimized for cheap subscription-backed usage with tools like Codex CLI and Claude CLI... A practical response to the reality that high-quality frontier models are expensive and vendor policies can tighten around third-party usage.
-- Compatible with OpenClaw-style configuration, commands and some concepts, agent personality for bot usecases, and workspace bootstrap templates, help Openclaw users to quickly get started.
-- Team-first by design, with agent bootstrap templates that fit shared team agents as well as personal ones.
-- Fits the emerging pattern of one personal assistant per employee and shared assistants per team.
-- Useful as a bot for coding, operations, teamwork, and general work in team environment, or on the go
-- Strong team support in Slack, with Telegram already supported as another first-class channel.
-- Configurable follow-up policy instead of a fixed TTL model, with a 5-minute default window and route-level controls so teams can tune behavior to how they actually work. Smart follow-up controls help avoid unwanted bot interruption in active threads: keep natural continuation when useful, or pause it when you want the bot to stay quiet until explicitly called again.
-- Fast operator shortcuts for shell execution: `!<command>` or `/bash <command>`, plus slash-prefix mappings such as `\bash` or `::bash` when Slack slash-command handling is incompatible. Turns Slack / Telegram into a terminal interface on the go.
-- The proof of concept already shows high potential beyond internal coding workflows, including customer chatbot use cases once messaging MCP or CLI-based skills let the agent send messages proactively in a cleaner way.
-
-## Current Focus
-
-`clisbot` is growing toward a broader agent runtime layer:
-
-- more CLI tool support beyond Claude Code and Codex, including Gemini CLI, OpenCode, Qwen, Kilo, and other agentic CLIs
-- more communication channels beyond Slack and Telegram, including Zalo, WhatsApp, Facebook, Discord, and future API-compatible surfaces
-- simple workflow building blocks such as cronjobs, heartbeat jobs, lightweight Ralph-style loops, and prompt combinations that just work
-- durable agent sessions, workspaces, follow-up policy, commands, attachments, and operator controls that stay reusable across all those surfaces
-
-tmux is still the current stability boundary. One agent maps to one durable runner session in one workspace, and every CLI, channel, or workflow layer should route onto that durable runtime instead of recreating the agent from scratch.
-
-## Launch MVP Path
-
-See [docs/overview/launch-mvp-path.md](docs/overview/launch-mvp-path.md) for the full current launch order.
-
-Short snapshot:
-
-1. Foundations first:
-   - frictionless start and credential persistence
-   - runtime stability and truthful status or debug UX
-   - `/loop` as the current differentiating workflow feature
-2. International launch gate:
-   - Claude, Codex, and Gemini as the well-tested core CLI trio
-   - current shared channel package remains Slack plus Telegram
-3. Vietnam launch package:
-   - add Zalo Official Account and Zalo Personal on top of the same core trio
-4. Next expansion wave:
-   - more CLIs such as Cursor, Amp, OpenCode, Qwen, Kilo, and Minimax, prioritized by real userbase demand
-   - more channels such as Discord, WhatsApp, Google Workspace, and Microsoft Teams
-5. Open launch decision:
-   - whether native CLI slash-command compatibility, override, and customization should ship before broader push
-
-## Showcase
-
-Slack
-
-![Slack showcase](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/slack-01.jpg)
+- One frontier-agent stack for both daily work and real coding. You do not need one product for assistant work and another for actual engineering work.
+- Learns from and integrates the two biggest strengths that made OpenClaw popular: memory and native channel integration with deep, channel-specific conversation and presentation capabilities.
+- Reuses native CLI subscriptions you already pay for, such as Claude Code, Codex, and Gemini CLI, instead of pushing you toward a separate API-cost-heavy stack.
+- Strong chat-first support in Slack and Telegram, with durable tmux-backed sessions behind the bot, so you can work from your laptop or on the go without giving up a real coding workspace.
+- Not just a tmux bridge. Slack and Telegram are treated as real channel surfaces with routing, thread or topic continuity, pairing, follow-up control, and attachment-aware interaction instead of plain text passthrough.
+- Files and images can move through the chat surfaces too, not just text prompts: inbound Slack or Telegram attachments can land in the workspace, and outbound channel delivery is designed around real message and media actions rather than terminal-only output.
+- Team-first by design, with `AGENTS`, `USER`, and `MEMORY` context bootstrapping shaped for shared team reality instead of only personal solo-assistant flows.
+- Useful for coding, operations, teamwork, and general assistant work, with fast shell shortcuts such as `!<command>` and `/bash <command>` when you need terminal-like control from chat.
 
-Telegram
+## What to expect
 
-![Telegram topic showcase 1](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-01.jpg)
-
-![Telegram topic showcase 2](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-02.jpg)
-
-![Telegram topic showcase 3](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-03.jpg)
+- You can get the first Telegram bot running in one command.
+- The first-run path creates one default agent and only enables the channels you explicitly name.
+- DMs start with pairing so access stays explicit.
+- `--persist` lets later restarts use plain `clisbot start`.
+- Slack and Telegram are not treated as plain-text sinks: routed conversations can carry thread or topic identity, pairing, and file-aware workflows.
+- Advanced multi-agent setup is available later, but it is not required for day one.
 
 ## Quick Start
 
-Fastest first-run path for the first Telegram bot:
-
-```bash
-clisbot start \
-  --cli codex \
-  --bot-type personal \
-  --telegram-bot-token <your-telegram-bot-token>
-```
-
-If you want later runs to work with plain `clisbot start`, persist that token immediately:
+Most people should start here:
 
 ```bash
+npm install -g clisbot
 clisbot start \
   --cli codex \
   --bot-type personal \
@@ -99,7 +46,16 @@ clisbot start \
   --persist
 ```
 
-What this does:
+If you want to try first without persisting the token yet, just remove `--persist`.
+
+Need the step-by-step setup docs instead of the shortest path?
+
+- Telegram: [Telegram Bot Setup](docs/user-guide/telegram-setup.md)
+- Slack: [Slack App Setup](docs/user-guide/slack-setup.md)
+- Slack app manifest template: [app-manifest.json](templates/slack/default/app-manifest.json)
+- Slack app manifest guide: [app-manifest-guide.md](templates/slack/default/app-manifest-guide.md)
+
+What happens next:
 
 - `--bot-type personal` creates one assistant for one human
 - `--bot-type team` creates one shared assistant for a team, channel, or group workflow
@@ -108,11 +64,14 @@ What this does:
 - fresh bootstrap only enables the channels you name explicitly
 - after the persisted first run, later restarts can use plain `clisbot start`
 
-Packaged CLI path:
+If you prefer Slack first:
 
 ```bash
-npm install -g clisbot
-clisbot start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token> --persist
+clisbot start \
+  --cli codex \
+  --bot-type team \
+  --slack-app-token SLACK_APP_TOKEN \
+  --slack-bot-token SLACK_BOT_TOKEN
 ```
 
 Short alias:
@@ -128,16 +87,6 @@ bun install
 bun run start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token> --persist
 ```
 
-If you prefer Slack first:
-
-```bash
-clisbot start \
-  --cli codex \
-  --bot-type team \
-  --slack-app-token SLACK_APP_TOKEN \
-  --slack-bot-token SLACK_BOT_TOKEN
-```
-
 First conversation path:
 
 - send a DM to the bot in Slack or Telegram
@@ -153,36 +102,57 @@ clisbot pairing approve telegram <CODE>
 
 Fresh config starts with no configured agents, so first-run `clisbot start` requires both `--cli` and `--bot-type` before it creates the first `default` agent.
 Fresh config also starts with no preconfigured Slack channels or Telegram groups or topics. Add those routes manually in `~/.clisbot/clisbot.json`.
-`clisbot start` requires explicit channel token input before it bootstraps anything. You can pass raw values, env names such as `TELEGRAM_BOT_TOKEN`, or placeholders such as `'${CUSTOM_TELEGRAM_BOT_TOKEN}'`.
-Set `CLISBOT_HOME` if you want a fully separate local config, state, tmux socket, wrapper, and workspace root, for example when running a dev instance beside your main bot.
+`clisbot start` requires explicit channel token input before it bootstraps anything. You can pass raw values, env names such as `MY_TELEGRAM_BOT_TOKEN`, or placeholders such as `'${MY_TELEGRAM_BOT_TOKEN}'`.
+If you want a separate dev instance beside your main bot, see the [Development Guide](docs/development/README.md).
+
+## Showcase
+
+The goal is a real chat-native agent surface, not a terminal transcript mirror: threads, topics, follow-up behavior, and file-aware workflows should feel native to Slack and Telegram.
+
+Slack
+
+![Slack showcase](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/slack-01.jpg)
+
+Telegram
+
+![Telegram topic showcase 1](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-01.jpg)
+
+![Telegram topic showcase 2](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-02.jpg)
+
+![Telegram topic showcase 3](https://raw.githubusercontent.com/longbkit/clisbot/main/docs/pics/telegram-03.jpg)
+
+## Important caution
+
+Strong vendor investment in security and safety does not make frontier agentic CLI tools inherently safe. `clisbot` exposes those tools more broadly through chat and workflow surfaces, so you should treat the whole system as high-trust software and use it at your own risk.
+
+## Acknowledgements
+
+`clisbot` would not exist without the ideas, momentum, and practical inspiration created by OpenClaw. Many configuration, routing, and workspace concepts here were learned from studying OpenClaw, then adapted to `clisbot`'s own direction. Respect and thanks to the OpenClaw project and community.
 
 ## Setup Guide
 
-The easiest setup flow is:
+The easiest setup flow is still:
+
+1. Install `clisbot`.
+2. Run the quick start command above.
+3. DM the bot and approve pairing.
+4. Only move into advanced config after the first successful run.
+
+If you want the repo-guided setup path:
 
 1. Clone this repo.
-2. Open Claude Code or Codex in this repo.
+2. Open Claude Code, Codex, or Gemini CLI in this repo.
 3. Ask it to help you set up `clisbot`.
 
 The docs in this repo are kept current, including the [User Guide](docs/user-guide/README.md), so the agent should have enough context to walk you through setup, configuration, and troubleshooting directly inside the repo.
 
-If you prefer to configure things yourself:
+If you prefer to configure everything yourself:
 
 1. Read the full config template in [config/clisbot.json.template](config/clisbot.json.template).
 2. Copy it to `~/.clisbot/clisbot.json` and adjust channels, bindings, workspaces, and policies for your environment.
 3. Add agents through the CLI so tool defaults, startup options, and bootstrap templates stay consistent.
 4. Optionally move stable channel secrets into env vars or canonical credential files after your first successful run.
 
-Separate dev home example:
-
-```bash
-export CLISBOT_HOME=~/.clisbot-dev
-clisbot start --cli codex --bot-type team --telegram-bot-token TELEGRAM_BOT_TOKEN
-```
-
-- `CLISBOT_HOME` changes the default config path, runtime state dir, tmux socket, local wrapper path, and default workspaces together
-- `CLISBOT_CONFIG_PATH` still works when you want to point at one exact config file manually
-
 Channel route setup is manual by design:
 
 - fresh config does not auto-add Slack channels
@@ -190,27 +160,12 @@ Channel route setup is manual by design:
 - add only the exact channel, group, topic, or DM routing you want to expose
 - default channel account setup lives in [docs/user-guide/channel-accounts.md](docs/user-guide/channel-accounts.md)
 
-Example agent setup:
+Advanced agent management:
 
-```bash
-clisbot start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token>
-```
-
-```bash
-clisbot agents add claude --cli claude --bootstrap team-assistant --bind telegram
-clisbot agents bootstrap claude --mode team-assistant --force
-clisbot agents list --bindings
-```
-
-Agent setup rules:
-
-- `agents add` requires `--cli` and currently supports `codex` and `claude`.
-- `--bootstrap` accepts `personal-assistant` or `team-assistant` and seeds the workspace from `templates/openclaw`, `templates/customized/default`, and the selected customized template.
-- `personal-assistant` fits one assistant for one human.
-- `team-assistant` fits one shared assistant for a team, channel, or group workflow.
-- `agents bootstrap <agentId> --mode <personal-assistant|team-assistant>` bootstraps an existing agent workspace using the agent's configured CLI tool.
-- bootstrap runs a dry check first; if any template markdown file already exists in the workspace, it stops and asks you to rerun with `--force`.
-- Fresh channel config still points at the `default` agent. If your first agent is not named `default`, update `defaultAgentId` and any route `agentId` values in config.
+- most users should stay on `clisbot start --cli ... --bot-type ...` and let first-run create the default agent
+- if you need more than one agent, custom bindings, or manual workspace bootstrap flows, use the `clisbot agents ...` commands described in [docs/user-guide/README.md](docs/user-guide/README.md)
+- README intentionally keeps that low-level surface out of the main onboarding path because the public first-run model is `--bot-type personal|team`, not internal template-mode naming
+- fresh channel config still points at the `default` agent; if your first agent uses another id, update `defaultAgentId` and any route `agentId` values in config
 
 Env-backed setup is still supported when you want config to reference an env name instead of persisting a credential file:
 
@@ -224,20 +179,20 @@ clisbot start \
 
 - these flags are written into `~/.clisbot/clisbot.json` as `${ENV_NAME}` placeholders
 - you can pass either `CUSTOM_SLACK_APP_TOKEN` or `'${CUSTOM_SLACK_APP_TOKEN}'`
-- use this path when your environment variable names differ from `SLACK_APP_TOKEN`, `SLACK_BOT_TOKEN`, or `TELEGRAM_BOT_TOKEN`
+- use this path when you want config to point at env variable names you chose yourself
 - keep env export details in [docs/user-guide/channel-accounts.md](docs/user-guide/channel-accounts.md) instead of front-loading them into quick start
 
 ## Troubleshooting
 
-- If setup feels unclear, open Claude Code or Codex in this repo and ask it to help using the local docs.
-- If you are still in doubt, clone `https://github.com/longbkit/clisbot`, open the repo in Codex or Claude Code, and ask questions about setup or the bot type choice.
+If the quick start does not work, check these in order:
+
+- If setup feels unclear, open Claude Code, Codex, or Gemini CLI in this repo and ask it to help using the local docs.
 - If config behavior is confusing, inspect [config/clisbot.json.template](config/clisbot.json.template) first, then compare it with [docs/user-guide/README.md](docs/user-guide/README.md).
 - If `clisbot start` says no agents are configured, prefer `clisbot start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token>`.
 - If you want later runs to work with plain `clisbot start`, rerun your successful first-run command with `--persist`.
 - If `clisbot start` prints token refs as `missing`, either pass the token explicitly on the command line or switch to env-backed setup described in [docs/user-guide/channel-accounts.md](docs/user-guide/channel-accounts.md).
 - If you use custom env names, pass them explicitly with `--slack-app-token`, `--slack-bot-token`, or `--telegram-bot-token`.
-- If `clisbot status` shows `bootstrap=...:missing`, the workspace is missing the tool-specific bootstrap file or `IDENTITY.md`; run `clisbot agents bootstrap <agentId> --mode <mode>`.
-- If `clisbot status` shows `bootstrap=...:not-bootstrapped`, finish the workspace bootstrap by reviewing `BOOTSTRAP.md`, `SOUL.md`, `IDENTITY.md`, and the mode-specific files in that workspace.
+- If `clisbot status` shows `bootstrap=...:missing` or `bootstrap=...:not-bootstrapped`, follow the advanced agent bootstrap steps in [docs/user-guide/README.md](docs/user-guide/README.md).
 - If Codex shows `Do you trust the contents of this directory?`, keep `trustWorkspace: true` in clisbot config and also mark the workspace as trusted in `~/.codex/config.toml`, for example:
 
 ```toml
@@ -246,6 +201,7 @@ trust_level = "trusted"
 ```
 
 - If that trust screen is still blocking, attach directly and continue from tmux with `tmux -S ~/.clisbot/state/clisbot.sock attach -t agent-default-main`.
+- If Gemini startup says it is waiting for manual authorization, authenticate Gemini directly first or provide a headless auth path such as `GEMINI_API_KEY` or Vertex AI credentials; `clisbot` now treats that screen as a startup blocker instead of a healthy ready session.
 - If Codex warns that `bubblewrap` is missing on Linux, install `bubblewrap` in the runtime environment.
 - If the bot does not answer, check that your shell environment really contains the expected tokens and restart `clisbot` after changing them.
 - If runtime startup still fails, run `clisbot logs` and inspect the recent log tail that `clisbot` now prints automatically on startup failure.
@@ -254,34 +210,29 @@ trust_level = "trusted"
 - If Slack thread behavior feels too eager, use `/followup pause` or `/followup mention-only`.
 - If Slack slash commands conflict with Slack-native command handling, add a leading space, for example ` /bash ls -la`.
 
-## Commands
+## Common CLI commands
+
+Most users only need a small set of commands at first:
 
 - `clisbot start`
 - `clisbot restart`
 - `clisbot stop`
-- `clisbot stop --hard`
 - `clisbot status`
 - `clisbot logs`
+- `clisbot pairing approve slack <CODE>`
+- `clisbot pairing approve telegram <CODE>`
 - `clisbot channels enable slack`
 - `clisbot channels enable telegram`
 - `clisbot channels add telegram-group <chatId> [--topic <topicId>] [--agent <id>] [--require-mention true|false]`
-- `clisbot channels remove telegram-group <chatId> [--topic <topicId>]`
 - `clisbot channels add slack-channel <channelId> [--agent <id>] [--require-mention true|false]`
-- `clisbot channels remove slack-channel <channelId>`
-- `clisbot channels add slack-group <groupId> [--agent <id>] [--require-mention true|false]`
-- `clisbot channels remove slack-group <groupId>`
-- `clisbot channels set-token <slack-app|slack-bot|telegram-bot> <value>`
-- `clisbot channels clear-token <slack-app|slack-bot|telegram-bot>`
 - `clisbot channels privilege enable <target>`
-- `clisbot channels privilege disable <target>`
 - `clisbot channels privilege allow-user <target> <userId>`
-- `clisbot channels privilege remove-user <target> <userId>`
 - `clisbot agents list --bindings`
-- `clisbot start --cli codex --bot-type personal --telegram-bot-token <your-telegram-bot-token> --persist`
-- `clisbot agents bootstrap default --mode personal-assistant`
-- `clisbot agents bind --agent default --bind telegram`
 - `clisbot agents bindings`
 - `clisbot --help`
+
+If you are running from the repo instead of the global package:
+
 - `bun run dev`
 - `bun run start`
 - `bun run restart`
@@ -340,23 +291,54 @@ Follow-up behavior matters in team threads:
 
 - [Overview](docs/overview/README.md)
 - [Architecture](docs/architecture/README.md)
+- [Development Guide](docs/development/README.md)
 - [Feature Tables](docs/features/feature-tables.md)
 - [Backlog](docs/tasks/backlog.md)
 - [User Guide](docs/user-guide/README.md)
 
 ## Roadmap
 
-- Webhook and OpenAI-compatible completion API to integrate with more workflows.
-- Heartbeat and cronjob support, with the note that Claude already has a useful cronjob path today through loop-style workflows.
-- Autodrive / hardwork mode.
-- Support more native CLIs such as Gemini, OpenCode, and others.
-- Experiment with json output mode from codex / claude code, Agent Client Protocol and native Codex SDK integration.
-- Experiment with native messaging tools so the bot can send Slack or Telegram messages through MCP or CLI-based skills instead of tmux pane capture, for more stable and natural public-facing behavior over time.
-- Add more channels on demand.
+- Add more native CLIs, starting with a stronger Claude, Codex, and Gemini launch trio.
+- Add more channels, starting from Slack and Telegram, then moving toward Zalo and other expansion surfaces.
+- Add better workflow building blocks such as heartbeat, cron-style jobs, and stronger loop automation.
+- Explore structured output, ACP, and native SDK integrations where they improve truthfulness or operator control.
+- Explore more stable native messaging paths beyond tmux-pane capture over time.
+
+## Current Focus
+
+`clisbot` is growing toward a broader agent runtime layer:
+
+- more CLI tool support beyond Claude Code, Codex, and Gemini CLI
+- more communication channels beyond Slack and Telegram
+- simple workflow building blocks such as cron jobs, heartbeat jobs, and loops
+- durable agent sessions, workspaces, follow-up policy, commands, attachments, and operator controls that stay reusable across all those surfaces
+
+tmux is still the current stability boundary. One agent maps to one durable runner session in one workspace, and every CLI, channel, or workflow layer should route onto that durable runtime instead of recreating the agent from scratch.
+
+## Launch MVP Path
+
+See [docs/overview/launch-mvp-path.md](docs/overview/launch-mvp-path.md) for the full current launch order.
+
+Short snapshot:
+
+1. Foundations first:
+   - frictionless start and credential persistence
+   - runtime stability and truthful status or debug UX
+   - `/loop` as the current differentiating workflow feature
+2. International launch gate:
+   - Claude, Codex, and Gemini as the well-tested core CLI trio
+   - current shared channel package remains Slack plus Telegram
+3. Vietnam launch package:
+   - add Zalo Official Account and Zalo Personal on top of the same core trio
+4. Next expansion wave:
+   - more CLIs such as Cursor, Amp, OpenCode, Qwen, Kilo, and Minimax, prioritized by real userbase demand
+   - more channels such as Discord, WhatsApp, Google Workspace, and Microsoft Teams
+5. Open launch decision:
+   - whether native CLI slash-command compatibility, override, and customization should ship before broader push
 
 ## Completed
 
-- [x] Multiple Codex and Claude sessions with streaming on/off support.
+- [x] Multiple Codex, Claude, and Gemini sessions with streaming on/off support.
 - [x] Stale tmux session cleanup and session resume.
 - [x] OpenClaw-compatible configuration system.
 - [x] Slack channel support with streaming and attachments, smart follow mode
@@ -366,7 +348,7 @@ Follow-up behavior matters in team threads:
 
 This repo also serves as a small example of an AI-native engineering workflow:
 
-- simple `AGENTS.md` and `CLAUDE.md`-style operating rules, short but addresses some common drawbacks of AI models as of 2026
+- simple `AGENTS.md` and `CLAUDE.md`-style operating rules
 - lessons-learned docs to capture repeated feedback and pitfalls
 - architecture docs used as a stable implementation contract
 - end-to-end validation expectations to close the feedback loop for AI agents

package/config/clisbot.json.template

@@ -1,7 +1,7 @@
 {
   "meta": {
     "schemaVersion": 1,
-    "lastTouchedAt": "2026-04-07T00:00:00.000Z"
+    "lastTouchedAt": "2026-04-15T00:00:00.000Z"
   },
   "tmux": {
     "socketPath": "~/.clisbot/state/clisbot.sock"
@@ -12,9 +12,81 @@
     "identityLinks": {},
     "storePath": "~/.clisbot/state/sessions.json"
   },
+  "app": {
+    "auth": {
+      "ownerClaimWindowMinutes": 30,
+      "defaultRole": "member",
+      "roles": {
+        "owner": {
+          "allow": [
+            "configManage",
+            "appAuthManage",
+            "agentAuthManage",
+            "promptGovernanceManage"
+          ],
+          "users": []
+        },
+        "admin": {
+          "allow": [
+            "configManage",
+            "appAuthManage",
+            "agentAuthManage",
+            "promptGovernanceManage"
+          ],
+          "users": []
+        },
+        "member": {
+          "allow": [],
+          "users": []
+        }
+      }
+    }
+  },
   "agents": {
     "defaults": {
       "workspace": "~/.clisbot/workspaces/{agentId}",
+      "auth": {
+        "defaultRole": "member",
+        "roles": {
+          "admin": {
+            "allow": [
+              "sendMessage",
+              "helpView",
+              "statusView",
+              "identityView",
+              "transcriptView",
+              "runObserve",
+              "runInterrupt",
+              "streamingManage",
+              "queueManage",
+              "steerManage",
+              "loopManage",
+              "shellExecute",
+              "runNudge",
+              "followupManage",
+              "responseModeManage",
+              "additionalMessageModeManage"
+            ],
+            "users": []
+          },
+          "member": {
+            "allow": [
+              "sendMessage",
+              "helpView",
+              "statusView",
+              "identityView",
+              "transcriptView",
+              "runObserve",
+              "runInterrupt",
+              "streamingManage",
+              "queueManage",
+              "steerManage",
+              "loopManage"
+            ],
+            "users": []
+          }
+        }
+      },
       "runner": {
         "command": "codex",
         "args": [
@@ -72,11 +144,20 @@
     "configReload": {
       "watch": true,
       "watchDebounceMs": 250
+    },
+    "sessionCleanup": {
+      "enabled": true,
+      "intervalMinutes": 5
+    },
+    "loop": {
+      "maxRunsPerLoop": 20,
+      "maxActiveLoops": 10,
+      "defaultTimezone": "UTC"
     }
   },
   "channels": {
     "slack": {
-      "enabled": true,
+      "enabled": false,
       "mode": "socket",
       "appToken": "${SLACK_APP_TOKEN}",
       "botToken": "${SLACK_BOT_TOKEN}",
@@ -104,10 +185,6 @@
       "channelPolicy": "allowlist",
       "groupPolicy": "allowlist",
       "defaultAgentId": "default",
-      "privilegeCommands": {
-        "enabled": false,
-        "allowUsers": []
-      },
       "commandPrefixes": {
         "slash": [
           "::",
@@ -121,6 +198,7 @@
       "response": "final",
       "responseMode": "message-tool",
       "additionalMessageMode": "steer",
+      "verbose": "minimal",
       "followUp": {
         "mode": "auto",
         "participationTtlMin": 5
@@ -132,15 +210,11 @@
         "policy": "pairing",
         "allowFrom": [],
         "requireMention": false,
-        "agentId": "default",
-        "privilegeCommands": {
-          "enabled": false,
-          "allowUsers": []
-        }
+        "agentId": "default"
       }
     },
     "telegram": {
-      "enabled": true,
+      "enabled": false,
       "mode": "polling",
       "botToken": "${TELEGRAM_BOT_TOKEN}",
       "defaultAccount": "default",
@@ -157,10 +231,6 @@
       "allowBots": false,
       "groupPolicy": "allowlist",
       "defaultAgentId": "default",
-      "privilegeCommands": {
-        "enabled": false,
-        "allowUsers": []
-      },
       "commandPrefixes": {
         "slash": [
           "::",
@@ -174,6 +244,7 @@
       "response": "final",
       "responseMode": "message-tool",
       "additionalMessageMode": "steer",
+      "verbose": "minimal",
       "followUp": {
         "mode": "auto",
         "participationTtlMin": 5
@@ -189,11 +260,7 @@
         "allowFrom": [],
         "requireMention": false,
         "allowBots": false,
-        "agentId": "default",
-        "privilegeCommands": {
-          "enabled": false,
-          "allowUsers": []
-        }
+        "agentId": "default"
       }
     }
   }