tiger-agent 0.3.1 → 0.3.2

package/.env.example

@@ -4,6 +4,13 @@
 # NEVER commit .env to git!
 # ============================================
 
+# Provider Routing (default: MiniMax)
+ACTIVE_PROVIDER=minimax
+PROVIDER_ORDER=minimax,claude,kimi,moonshot,zai
+MINIMAX_API_KEY=your_minimax_api_key_here
+MINIMAX_BASE_URL=https://api.minimax.io/v1
+MINIMAX_MODEL=MiniMax-M2.5
+
 # Google Gemini (for image generation)
 GEMINI_API_KEY=your_gemini_api_key_here
 
@@ -12,6 +19,8 @@ TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
 TELEGRAM_CHAT_ID=8172556270
 # Swarm agent step timeout in ms (0 = no extra swarm timeout)
 SWARM_AGENT_TIMEOUT_MS=0
+# Start Telegram swarm routing enabled or disabled (true/false)
+SWARM_ENABLED=false
 # Swarm-only provider failover on timeout/network/API error (true/false)
 SWARM_ROUTE_ON_PROVIDER_ERROR=false
 # Swarm default flow for new Telegram tasks (auto|design|research_build)

package/.env.secrets.example

@@ -7,6 +7,9 @@ MOONSHOT_API_KEY=
 # Kimi Code API key (used when KIMI_PROVIDER=code)
 KIMI_CODE_API_KEY=
 
+# MiniMax API key
+MINIMAX_API_KEY=
+
 # Backward-compatible alias (optional)
 KIMI_API_KEY=
 

package/README.md

@@ -54,6 +54,32 @@ Made by **AI Research Group, Department of Civil Engineering, KMUTT**
 | **Channels** | CLI + Telegram simultaneously | Single channel only |
 | **Execution** | Chains multiple skills autonomously | Single command only |
 
+## 📊 Dimension Comparison
+
+| Dimension | Tiger v0.3.1 🐯 | OpenClaw 🔧 | NanoClaw 🪐 |
+|---|---|---|---|
+| Language | JS + Python | TypeScript | TypeScript |
+| Platform | Linux + Docker | macOS/Linux/Win | macOS/Linux/Win |
+| Install | `npm install -g tiger-agent` | `npm install -g openclaw` | `git clone` + Claude Code |
+| LLM Providers | 5 (Kimi, Z.ai, MiniMax, Claude, Moonshot) | OpenAI + Claude | Claude only |
+| Multi-provider Failover | ✅ Auto on 429/403 | ✅ | ❌ |
+| Token Budgeting | ✅ Per-provider daily limits | ❌ | ❌ |
+| Predefined Agents | ✅ Role-based, customizable via Markdown files | ✅ Built-in typed agents | ❌ User-defined only |
+| Swarm Architecture | ✅ YAML configurable | ❌ | ❌ |
+| Parallel Execution | ✅ Fault-tolerant `min_success` threshold | ✅ | ✅ |
+| Judgment Matrix | ✅ Weighted criteria + review-revise loop | ❌ | ❌ |
+| Task Resume | ✅ `/task continue <id>` | ❌ | ❌ |
+| Crash Detection | ✅ 60s heartbeat; 5-min stale -> restart worker | ❌ | ✅ 5-min -> reclaim tasks |
+| Container Isolation | ✅ Docker hardened (`cap_drop: ALL`, read-only FS) | Optional Docker | ✅ Docker default |
+| Memory Persistence | ✅ Cross-session SQLite + 30-day backup | Session only | Team lifetime only |
+| Self-learning | ✅ 12h reflection + 24h regeneration | ❌ | ❌ |
+| Vector Retrieval | ✅ sqlite-vec / cosine fallback | ❌ | ❌ |
+| Audit Logging | ✅ | ❌ | ❌ |
+| Voice / Browser | ❌ / ❌ | ✅ / ✅ | ❌ / ❌ |
+| Channel Coverage | Telegram, WhatsApp, CLI | All + iMessage + Teams | Most major |
+| Core Strength | Cost control + YAML swarm + self-learning | Channel breadth + voice + sync A2A | Security + formal swarm lifecycle |
+| Core Weakness | Linux-primary; no cross-task DAG | High complexity; app-layer security | Single-provider lock-in |
+
 ---
 
 ## 📋 Requirements
@@ -72,16 +98,60 @@ npm install -g tiger-agent
 
 All config and runtime data is stored in `~/.tiger/` — nothing written to the npm global directory.
 
+## 🐳 Docker (Safer Runtime Isolation)
+
+Run Tiger in a hardened container with:
+- non-root user (`node`)
+- dropped Linux capabilities (`cap_drop: [ALL]`)
+- `no-new-privileges`
+- read-only root filesystem
+- persistent writable volume only for `TIGER_HOME` (`/home/node/.tiger`)
+
+Build image:
+
+```bash
+docker build -t tiger-agent:local .
+```
+
+Run CLI mode:
+
+```bash
+docker run --rm -it \
+  --env-file .env \
+  --read-only \
+  --tmpfs /tmp \
+  --security-opt no-new-privileges:true \
+  --cap-drop ALL \
+  -e TIGER_HOME=/home/node/.tiger \
+  -v tiger_home:/home/node/.tiger \
+  tiger-agent:local start
+```
+
+Run Telegram mode via Compose:
+
+```bash
+docker compose up -d
+docker compose logs -f tiger
+```
+
+Default compose command is `telegram`. Change `command:` in `docker-compose.yml` if you want `start` instead.
+
 ---
 
 ## 🚀 Quick Start
 
-### 1. Run the setup wizard
+### 1. Run the setup wizard (`npm`, not `npn`)
 
 ```bash
 tiger onboard
 ```
 
+If you cloned this repo and run locally (without global install), use:
+
+```bash
+npm run onboard
+```
+
 The wizard will ask for:
 - **Active provider** — which LLM to use by default (e.g. `zai`, `claude`)
 - **Fallback order** — comma-separated list tried when the active provider is rate-limited
@@ -92,25 +162,45 @@ The wizard will ask for:
 
 Config is saved to `~/.tiger/.env` (mode 600).
 
+**MiniMax starter (quick setup):**
+```bash
+# during onboard: choose active provider = minimax
+tiger onboard
+# local repo alternative
+# npm run onboard
+```
+Set at least:
+- `ACTIVE_PROVIDER=minimax`
+- `MINIMAX_API_KEY=...`
+
 ### 2. Start
 
 **CLI chat:**
 ```bash
 tiger start
+# local repo
+npm run start
 ```
 Exit with `/exit` or `/quit`.
 
 **Telegram bot (foreground):**
 ```bash
 tiger telegram
+# local repo
+npm run telegram
 ```
+Use foreground mode only for testing/log watching in the current terminal session.
 
 **Telegram bot (background daemon):**
 ```bash
 tiger telegram --background   # start
 tiger status                  # check if running
 tiger stop                    # stop
+# local repo
+npm run telegram:bg           # start
+npm run telegram:stop         # stop
 ```
+Recommended for daily use: run background mode so Tiger keeps running after you close the terminal.
 
 **Restart background bot (after editing `.env` in this repo):**
 ```bash
@@ -134,6 +224,11 @@ Logs: `~/.tiger/logs/telegram.out.log`
 | **Status** | `tiger status` | Check daemon status |
 | **Onboard** | `tiger onboard` | Re-run setup wizard |
 
+Background crash detection:
+- Telegram worker now emits a heartbeat every 60 seconds.
+- Supervisor watchdog checks heartbeat every minute.
+- If heartbeat is stale for 5 minutes, supervisor force-restarts the worker.
+
 ---
 
 ## 🔧 Setup Wizard Details
@@ -186,7 +281,7 @@ Tiger supports **5 providers** with automatic fallback and daily token limits.
 | Kimi Code | `kimi` | `k2p5` | `KIMI_CODE_API_KEY` |
 | Kimi Moonshot | `moonshot` | `kimi-k1` | `MOONSHOT_API_KEY` |
 | Z.ai (Zhipu) | `zai` | `glm-4.7` | `ZAI_API_KEY` (format: `id.secret`) |
-| MiniMax | `minimax` | `abab6.5s-chat` | `MINIMAX_API_KEY` |
+| MiniMax | `minimax` | `MiniMax-M2.5` | `MINIMAX_API_KEY` |
 | Claude (Anthropic) | `claude` | `claude-sonnet-4-6` | `CLAUDE_API_KEY` |
 
 ### `.env` Example
@@ -218,6 +313,10 @@ SWARM_AGENT_TIMEOUT_MS=120000
 # Swarm only: on timeout/network/API error, retry via next provider
 SWARM_ROUTE_ON_PROVIDER_ERROR=true
 
+# Swarm execution resilience
+SWARM_STEP_MAX_RETRIES=2
+SWARM_CONTINUE_ON_ERROR=true
+
 # Swarm task entry policy
 SWARM_DEFAULT_FLOW=auto
 SWARM_FIRST_AGENT_POLICY=auto
@@ -267,17 +366,20 @@ SWARM_FIRST_AGENT=designer
 
 Tiger v0.3.1 includes an internal agent swarm for Telegram message routing.
 
-- **Default:** swarm is **ON** when the Telegram bot starts
+- **Default:** swarm is **OFF** when the Telegram bot starts (`SWARM_ENABLED=false`)
 - **`/swarm on`**: regular user messages are routed through the YAML architecture in `swarm/architecture/*.yaml` (selected by `tasks/styles/default.yaml`)
 - **`/swarm off`**: regular user messages skip the swarm and go directly to the standard Tiger agent reply path
 - **Scope:** this toggle affects only **normal chat messages** (not admin commands like `/api`, `/tokens`, `/limit`)
-- **Current persistence:** the `/swarm` toggle is currently **in-memory only** and resets to **ON** after bot restart
+- **Current persistence:** the `/swarm` toggle is currently **in-memory only** and resets to `SWARM_ENABLED` value after bot restart
 - **Task resume:** use `/task continue <task_id>` (or `/task retry <task_id>`) to continue a failed timeout/API-error task without starting over
 
 ### Swarm Timeout / Failover (`.env`)
 
 - `SWARM_AGENT_TIMEOUT_MS`: timeout per swarm worker step (e.g. one `designer` turn). `0` disables the extra swarm timeout.
+- `SWARM_ENABLED=true|false`: default `/swarm` state at bot startup.
 - `SWARM_ROUTE_ON_PROVIDER_ERROR=true|false`: swarm-only provider failover on timeout/network/API errors.
+- `SWARM_STEP_MAX_RETRIES`: retries per failed worker/stage before giving up.
+- `SWARM_CONTINUE_ON_ERROR=true|false`: if `true`, swarm continues on degraded path after retries are exhausted (instead of hard failing).
 - Provider timeouts are separate and provider-specific, for example `KIMI_TIMEOUT_MS`, `ZAI_TIMEOUT_MS`, `CLAUDE_TIMEOUT_MS`.
 
 ### Swarm Entry Policy (`.env`)
@@ -364,6 +466,14 @@ Default architecture behavior:
 - Stage 3: selected designer revises based on reviewer feedback (loop until approved)
 - Stage 4: `spec_writer` writes final output in two sections: **Calculation Report** and **Executive Summary**
 
+Resilient execution behavior:
+
+- Parallel stages are fault-tolerant: one failed role does not abort the whole stage.
+- `type: parallel` now supports `min_success` (default `1`) to define how many successful role outputs are required.
+- Failed parallel-role errors are stored in context as `<store_as>_errors`.
+- Worker/stage retries are controlled by `SWARM_STEP_MAX_RETRIES`.
+- If retries are exhausted and `SWARM_CONTINUE_ON_ERROR=true`, swarm continues on a degraded path instead of hard fail.
+
 Example `swarm/architecture/tiger_parallel_design.yaml`:
 
 ```yaml
@@ -394,6 +504,7 @@ stages:
       - designer_a
       - designer_b
       - designer_c
+    min_success: 2
     store_as: design_candidates
     next: review_best
   - id: review_best

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiger-agent",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Cognitive AI agent with persistent memory, multi-provider LLM, and Telegram bot",
   "type": "commonjs",
   "main": "src/cli.js",

package/scripts/onboard.js

@@ -60,6 +60,19 @@ function envLine(k, v) {
   return `${k}=${s}`;
 }
 
+const KNOWN_PROVIDERS = ['minimax', 'zai', 'claude', 'kimi', 'moonshot'];
+
+function parseProviderList(input, fallback = []) {
+  const raw = String(input || '').trim();
+  const values = (raw ? raw : fallback.join(','))
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+  const unique = [...new Set(values)];
+  const invalid = unique.filter((p) => !KNOWN_PROVIDERS.includes(p));
+  return { providers: unique, invalid };
+}
+
 // ─── Daemon helpers ───────────────────────────────────────────────────────────
 
 function nodeBin() {
@@ -180,32 +193,87 @@ Config will be saved to: ${TIGER_HOME}
     if (!yn(ow, false)) { console.log('Cancelled.'); rl.close(); return; }
   }
 
-  // ── Active provider ────────────────────────────────────────────────────────
-  console.log('\nAvailable providers: kimi, zai (Zhipu GLM-4.7), minimax, claude, moonshot');
-  const activeProv = (await ask('Active provider (zai): ')).trim() || 'zai';
-  const provOrder = (await ask(`Provider fallback order (${activeProv},claude,kimi,minimax,moonshot): `)).trim()
-    || `${activeProv},claude,kimi,minimax,moonshot`;
+  // ── Provider selection / routing ──────────────────────────────────────────
+  console.log('\nAvailable providers: minimax, zai (Zhipu GLM-4.7), claude, kimi, moonshot');
+  console.log('Choose only providers you want to configure. Others will be omitted from .env.');
+
+  let selectedProviders = [];
+  while (!selectedProviders.length) {
+    const picked = await ask('Providers to configure (comma-separated, default: minimax): ');
+    const parsed = parseProviderList(picked, ['minimax']);
+    if (parsed.invalid.length) {
+      console.log(`Invalid provider(s): ${parsed.invalid.join(', ')}. Try again.`);
+      continue;
+    }
+    if (!parsed.providers.length) {
+      console.log('Pick at least one provider.');
+      continue;
+    }
+    selectedProviders = parsed.providers;
+  }
+
+  const activeDefault = selectedProviders[0];
+  let activeProv = '';
+  while (!activeProv) {
+    const candidate = (await ask(`Active provider (${activeDefault}): `)).trim().toLowerCase() || activeDefault;
+    if (!selectedProviders.includes(candidate)) {
+      console.log(`Active provider must be one of: ${selectedProviders.join(', ')}`);
+      continue;
+    }
+    activeProv = candidate;
+  }
 
-  // ── API keys ───────────────────────────────────────────────────────────────
-  console.log('\nEnter API keys (press Enter to skip a provider):');
+  const orderDefault = [activeProv, ...selectedProviders.filter((p) => p !== activeProv)].join(',');
+  let provOrder = '';
+  while (!provOrder) {
+    const input = await ask(`Provider fallback order (${orderDefault}): `);
+    const parsed = parseProviderList(input, [activeProv, ...selectedProviders.filter((p) => p !== activeProv)]);
+    if (parsed.invalid.length) {
+      console.log(`Invalid provider(s): ${parsed.invalid.join(', ')}. Try again.`);
+      continue;
+    }
+    const outsideSelection = parsed.providers.filter((p) => !selectedProviders.includes(p));
+    if (outsideSelection.length) {
+      console.log(`Order can only include selected providers: ${selectedProviders.join(', ')}`);
+      continue;
+    }
+    if (!parsed.providers.includes(activeProv)) {
+      console.log(`Order must include active provider: ${activeProv}`);
+      continue;
+    }
+    provOrder = parsed.providers.join(',');
+  }
 
-  const kimiKey    = (await askHidden('  KIMI_CODE_API_KEY  : ')).trim();
-  const moonshotKey= (await askHidden('  MOONSHOT_API_KEY   : ')).trim();
-  const zaiKey     = (await askHidden('  ZAI_API_KEY        : ')).trim();
-  const minimaxKey = (await askHidden('  MINIMAX_API_KEY    : ')).trim();
-  const claudeKey  = (await askHidden('  CLAUDE_API_KEY     : ')).trim();
+  // ── API keys ───────────────────────────────────────────────────────────────
+  console.log('\nEnter API keys for selected providers:');
+  const kimiKey = selectedProviders.includes('kimi') ? (await askHidden('  KIMI_CODE_API_KEY  : ')).trim() : '';
+  const moonshotKey = selectedProviders.includes('moonshot') ? (await askHidden('  MOONSHOT_API_KEY   : ')).trim() : '';
+  const zaiKey = selectedProviders.includes('zai') ? (await askHidden('  ZAI_API_KEY        : ')).trim() : '';
+  const minimaxKey = selectedProviders.includes('minimax') ? (await askHidden('  MINIMAX_API_KEY    : ')).trim() : '';
+  const claudeKey = selectedProviders.includes('claude') ? (await askHidden('  CLAUDE_API_KEY     : ')).trim() : '';
 
   // ── Telegram ───────────────────────────────────────────────────────────────
   console.log('');
   const tgToken = (await askHidden('  TELEGRAM_BOT_TOKEN : ')).trim();
 
   // ── Token limits ───────────────────────────────────────────────────────────
-  console.log('\nDaily token limits per provider (0 = unlimited, auto-switch on breach):');
-  const kimiLimit    = (await ask('  KIMI_TOKEN_LIMIT    (100000): ')).trim() || '100000';
-  const moonshotLimit= (await ask('  MOONSHOT_TOKEN_LIMIT(100000): ')).trim() || '100000';
-  const zaiLimit     = (await ask('  ZAI_TOKEN_LIMIT     (100000): ')).trim() || '100000';
-  const minimaxLimit = (await ask('  MINIMAX_TOKEN_LIMIT (100000): ')).trim() || '100000';
-  const claudeLimit  = (await ask('  CLAUDE_TOKEN_LIMIT  (500000): ')).trim() || '500000';
+  const tokenLimits = {};
+  console.log('\nDaily token limits for selected providers (0 = unlimited, auto-switch on breach):');
+  if (selectedProviders.includes('kimi')) {
+    tokenLimits.kimi = (await ask('  KIMI_TOKEN_LIMIT    (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('moonshot')) {
+    tokenLimits.moonshot = (await ask('  MOONSHOT_TOKEN_LIMIT(100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('zai')) {
+    tokenLimits.zai = (await ask('  ZAI_TOKEN_LIMIT     (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('minimax')) {
+    tokenLimits.minimax = (await ask('  MINIMAX_TOKEN_LIMIT (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('claude')) {
+    tokenLimits.claude = (await ask('  CLAUDE_TOKEN_LIMIT  (500000): ')).trim() || '500000';
+  }
 
   // ── Misc ───────────────────────────────────────────────────────────────────
   const allowShell = yn(await ask('\nEnable shell tool? (y/N): '), false);
@@ -215,51 +283,80 @@ Config will be saved to: ${TIGER_HOME}
   const lines = [
     '# Tiger Agent config — generated by `tiger onboard`',
     '',
-    '# ── Legacy Kimi compat (used if ACTIVE_PROVIDER=kimi)',
-    envLine('KIMI_PROVIDER', 'code'),
-    envLine('KIMI_CODE_API_KEY', kimiKey),
-    envLine('KIMI_BASE_URL', 'https://api.kimi.com/coding/v1'),
-    envLine('KIMI_CHAT_MODEL', 'kimi-coding/k2p5'),
-    envLine('KIMI_EMBED_MODEL', ''),
-    envLine('KIMI_USER_AGENT', 'KimiCLI/0.77'),
-    envLine('KIMI_ENABLE_EMBEDDINGS', 'false'),
-    envLine('KIMI_TIMEOUT_MS', '30000'),
-    '',
     '# ── Multi-provider',
     envLine('ACTIVE_PROVIDER', activeProv),
     envLine('PROVIDER_ORDER', provOrder),
-    '',
-    '# ── Z.ai (Zhipu GLM)',
-    envLine('ZAI_API_KEY', zaiKey),
-    envLine('ZAI_BASE_URL', 'https://api.z.ai/api/coding/paas/v4'),
-    envLine('ZAI_MODEL', 'glm-4.7'),
-    envLine('ZAI_TIMEOUT_MS', '30000'),
-    '',
-    '# ── MiniMax',
-    envLine('MINIMAX_API_KEY', minimaxKey),
-    envLine('MINIMAX_BASE_URL', 'https://api.minimax.chat/v1'),
-    envLine('MINIMAX_MODEL', 'abab6.5s-chat'),
-    envLine('MINIMAX_TIMEOUT_MS', '30000'),
-    '',
-    '# ── Claude (Anthropic)',
-    envLine('CLAUDE_API_KEY', claudeKey),
-    envLine('CLAUDE_MODEL', 'claude-sonnet-4-6'),
-    envLine('CLAUDE_TIMEOUT_MS', '60000'),
-    '',
-    '# ── Moonshot',
-    envLine('MOONSHOT_API_KEY', moonshotKey),
-    envLine('MOONSHOT_BASE_URL', 'https://api.moonshot.cn/v1'),
-    envLine('MOONSHOT_MODEL', 'kimi-k1'),
-    '',
-    '# ── Token limits (daily, 0 = unlimited)',
-    envLine('KIMI_TOKEN_LIMIT', kimiLimit),
-    envLine('MOONSHOT_TOKEN_LIMIT', moonshotLimit),
-    envLine('ZAI_TOKEN_LIMIT', zaiLimit),
-    envLine('MINIMAX_TOKEN_LIMIT', minimaxLimit),
-    envLine('CLAUDE_TOKEN_LIMIT', claudeLimit),
+    ''
+  ];
+
+  if (selectedProviders.includes('kimi')) {
+    lines.push(
+      '# ── Legacy Kimi compat (used if ACTIVE_PROVIDER=kimi)',
+      envLine('KIMI_PROVIDER', 'code'),
+      envLine('KIMI_CODE_API_KEY', kimiKey),
+      envLine('KIMI_BASE_URL', 'https://api.kimi.com/coding/v1'),
+      envLine('KIMI_CHAT_MODEL', 'kimi-coding/k2p5'),
+      envLine('KIMI_EMBED_MODEL', ''),
+      envLine('KIMI_USER_AGENT', 'KimiCLI/0.77'),
+      envLine('KIMI_ENABLE_EMBEDDINGS', 'false'),
+      envLine('KIMI_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('zai')) {
+    lines.push(
+      '# ── Z.ai (Zhipu GLM)',
+      envLine('ZAI_API_KEY', zaiKey),
+      envLine('ZAI_BASE_URL', 'https://api.z.ai/api/coding/paas/v4'),
+      envLine('ZAI_MODEL', 'glm-4.7'),
+      envLine('ZAI_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('minimax')) {
+    lines.push(
+      '# ── MiniMax (Coding / OpenAI-compatible)',
+      envLine('MINIMAX_API_KEY', minimaxKey),
+      envLine('MINIMAX_BASE_URL', 'https://api.minimax.io/v1'),
+      envLine('MINIMAX_MODEL', 'MiniMax-M2.5'),
+      envLine('MINIMAX_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('claude')) {
+    lines.push(
+      '# ── Claude (Anthropic)',
+      envLine('CLAUDE_API_KEY', claudeKey),
+      envLine('CLAUDE_MODEL', 'claude-sonnet-4-6'),
+      envLine('CLAUDE_TIMEOUT_MS', '60000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('moonshot')) {
+    lines.push(
+      '# ── Moonshot',
+      envLine('MOONSHOT_API_KEY', moonshotKey),
+      envLine('MOONSHOT_BASE_URL', 'https://api.moonshot.cn/v1'),
+      envLine('MOONSHOT_MODEL', 'kimi-k1'),
+      ''
+    );
+  }
+
+  lines.push('# ── Token limits (daily, 0 = unlimited)');
+  if (tokenLimits.kimi != null) lines.push(envLine('KIMI_TOKEN_LIMIT', tokenLimits.kimi));
+  if (tokenLimits.moonshot != null) lines.push(envLine('MOONSHOT_TOKEN_LIMIT', tokenLimits.moonshot));
+  if (tokenLimits.zai != null) lines.push(envLine('ZAI_TOKEN_LIMIT', tokenLimits.zai));
+  if (tokenLimits.minimax != null) lines.push(envLine('MINIMAX_TOKEN_LIMIT', tokenLimits.minimax));
+  if (tokenLimits.claude != null) lines.push(envLine('CLAUDE_TOKEN_LIMIT', tokenLimits.claude));
+  lines.push(
     '',
     '# ── Telegram',
     envLine('TELEGRAM_BOT_TOKEN', tgToken),
+    envLine('SWARM_ENABLED', 'false'),
     '',
     '# ── Permissions',
     envLine('ALLOW_SHELL', allowShell ? 'true' : 'false'),
@@ -280,7 +377,7 @@ Config will be saved to: ${TIGER_HOME}
     'MEMORY_INGEST_EVERY_TURNS=2',
     'MEMORY_INGEST_MIN_CHARS=140',
     ''
-  ];
+  );
 
   fs.writeFileSync(ENV_PATH, lines.join('\n'), { mode: 0o600 });
   console.log(`\n✅  Config written to ${ENV_PATH}`);
@@ -307,7 +404,7 @@ Setup complete! 🐯
 Start CLI:           tiger start
 Start Telegram:      tiger telegram
 Background daemon:   tiger telegram --background
-Switch provider:     /api claude   (in Telegram chat)
+Switch provider:     /api <provider_id>   (in Telegram chat)
 Token usage:         /tokens       (in Telegram chat)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
 

package/src/apiProviders.js

@@ -177,8 +177,8 @@ function buildProviders(env) {
     minimax: {
       id: 'minimax',
       name: 'MiniMax',
-      baseUrl: (env.MINIMAX_BASE_URL || 'https://api.minimax.chat/v1').replace(/\/$/, ''),
-      chatModel: env.MINIMAX_MODEL || 'abab6.5s-chat',
+      baseUrl: (env.MINIMAX_BASE_URL || 'https://api.minimax.io/v1').replace(/\/$/, ''),
+      chatModel: env.MINIMAX_MODEL || 'MiniMax-M2.5',
       embedModel: env.MINIMAX_EMBED_MODEL || '',
       apiKey: env.MINIMAX_API_KEY || '',
       userAgent: '',

package/src/cli.js

@@ -16,6 +16,7 @@ const srcRoot = path.resolve(__dirname, '..');
 // Runtime root — inside TIGER_HOME when installed globally, otherwise project root
 const rootDir = process.env.TIGER_HOME || process.cwd();
 const supervisorPidPath = path.resolve(rootDir, 'tiger-telegram.pid');
+const workerHeartbeatPath = path.resolve(rootDir, 'tiger-telegram-worker.heartbeat');
 
 process.on('unhandledRejection', (reason) => {
   const msg = reason && reason.stack ? reason.stack : String(reason);
@@ -34,6 +35,14 @@ function hasFlag(argv, flag) {
   return argv.includes(flag);
 }
 
+function writeWorkerHeartbeat() {
+  try {
+    fs.writeFileSync(workerHeartbeatPath, `${Date.now()}\n`, 'utf8');
+  } catch (err) {
+    // Heartbeat is best-effort and must not crash the worker.
+  }
+}
+
 function isPidRunning(pid) {
   if (!pid) return false;
   try {
@@ -87,7 +96,9 @@ function stopTelegramBackground() {
   process.kill(pid, 'SIGTERM');
   fs.unlinkSync(supervisorPidPath);
   const workerPidPath = path.resolve(rootDir, 'tiger-telegram-worker.pid');
+  const workerHeartbeatPath = path.resolve(rootDir, 'tiger-telegram-worker.heartbeat');
   if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+  if (fs.existsSync(workerHeartbeatPath)) fs.unlinkSync(workerHeartbeatPath);
   process.stdout.write(`Stopped Telegram background bot (supervisor PID ${pid}).\n`);
 }
 
@@ -162,6 +173,7 @@ async function runCli() {
 
 async function main() {
   const argv = process.argv.slice(2);
+  const isWorkerProcess = hasFlag(argv, '--worker');
   if (hasFlag(argv, '--telegram-stop')) {
     stopTelegramBackground();
     return;
@@ -178,6 +190,11 @@ async function main() {
     startReflectionScheduler();
     const vectorStatus = initVectorMemory();
     printVectorMemoryStatus(vectorStatus);
+    if (isWorkerProcess) {
+      // NanoClaw-style heartbeat: worker emits liveness every minute.
+      writeWorkerHeartbeat();
+      setInterval(writeWorkerHeartbeat, 60 * 1000);
+    }
     startTelegramBot();
     process.stdout.write('Telegram bot started.\n');
     return;

package/src/config.js

@@ -107,6 +107,11 @@ const swarmRouteOnProviderError =
 const swarmDefaultFlow = cleanEnvValue(process.env.SWARM_DEFAULT_FLOW || 'auto').toLowerCase() || 'auto';
 const swarmFirstAgentPolicy = cleanEnvValue(process.env.SWARM_FIRST_AGENT_POLICY || 'auto').toLowerCase() || 'auto';
 const swarmFirstAgent = cleanEnvValue(process.env.SWARM_FIRST_AGENT || '').toLowerCase();
+const swarmStepMaxRetries = Math.max(0, Number(process.env.SWARM_STEP_MAX_RETRIES || 2));
+const swarmContinueOnError =
+  ['1', 'true', 'yes', 'on'].includes(cleanEnvValue(process.env.SWARM_CONTINUE_ON_ERROR || 'true').toLowerCase());
+const swarmEnabled =
+  ['1', 'true', 'yes', 'on'].includes(cleanEnvValue(process.env.SWARM_ENABLED || 'false').toLowerCase());
 
 module.exports = {
   kimiProvider,
@@ -138,6 +143,9 @@ module.exports = {
   swarmDefaultFlow,
   swarmFirstAgentPolicy,
   swarmFirstAgent,
+  swarmStepMaxRetries,
+  swarmContinueOnError,
+  swarmEnabled,
   dbPath: path.resolve(process.env.DB_PATH || './db/agent.json'),
   maxMessages: Number(process.env.MAX_MESSAGES || 200),
   recentMessages: Number(process.env.RECENT_MESSAGES || 40)

package/src/swarm/agentRuntime.js

@@ -8,7 +8,9 @@ const {
   swarmRouteOnProviderError,
   swarmDefaultFlow,
   swarmFirstAgentPolicy,
-  swarmFirstAgent
+  swarmFirstAgent,
+  swarmStepMaxRetries,
+  swarmContinueOnError
 } = require('../config');
 const {
   AGENTS_DIR,
@@ -85,6 +87,34 @@ function getTaskContext(task) {
   return task.metadata.swarm_ctx;
 }
 
+function getRetryState(task) {
+  if (!task.metadata || typeof task.metadata !== 'object') task.metadata = {};
+  if (!task.metadata.retry_state || typeof task.metadata.retry_state !== 'object') {
+    task.metadata.retry_state = {};
+  }
+  const state = task.metadata.retry_state;
+  if (!state.workers || typeof state.workers !== 'object') state.workers = {};
+  if (!state.stages || typeof state.stages !== 'object') state.stages = {};
+  return state;
+}
+
+function markRetryAttempt(task, scope, key) {
+  const state = getRetryState(task);
+  const store = scope === 'stage' ? state.stages : state.workers;
+  const k = String(key || '').trim();
+  if (!k) return 1;
+  store[k] = Number(store[k] || 0) + 1;
+  return store[k];
+}
+
+function clearRetryAttempts(task, scope, key) {
+  const state = getRetryState(task);
+  const store = scope === 'stage' ? state.stages : state.workers;
+  const k = String(key || '').trim();
+  if (!k) return;
+  delete store[k];
+}
+
 function resolveRoleMap(architecture) {
   const out = {};
   const agents = Array.isArray(architecture && architecture.agents) ? architecture.agents : [];
@@ -281,7 +311,7 @@ async function runArchitectureStage(task, architecture, stage) {
 
   if (stageType === 'parallel') {
     const roles = Array.isArray(stage.roles) ? stage.roles.map((x) => String(x || '').trim()).filter(Boolean) : [];
-    const outputs = await Promise.all(roles.map(async (roleId) => {
+    const roleRuns = await Promise.allSettled(roles.map(async (roleId) => {
       const role = roleMap[roleId] || { runtimeAgent: roleId };
       const text = await runRoleStep(
         task,
@@ -293,11 +323,37 @@ async function runArchitectureStage(task, architecture, stage) {
       );
       return { role: roleId, runtime_agent: role.runtimeAgent, text };
     }));
+    const outputs = [];
+    const failures = [];
+    for (let i = 0; i < roleRuns.length; i += 1) {
+      const roleId = roles[i];
+      const outcome = roleRuns[i];
+      if (outcome.status === 'fulfilled') {
+        outputs.push(outcome.value);
+      } else {
+        failures.push({
+          role: roleId,
+          error: String(outcome.reason && outcome.reason.message ? outcome.reason.message : outcome.reason || 'unknown error')
+        });
+      }
+    }
+
     for (const out of outputs) {
       appendThread(task, out.role, out.text || `${out.role} completed step`);
     }
+    for (const fail of failures) {
+      appendThread(task, fail.role, `error: ${fail.error}`);
+    }
+
     const key = String(stage.store_as || `${stage.id}_outputs`).trim();
     ctx[key] = outputs;
+    ctx[`${key}_errors`] = failures;
+    const minSuccess = Math.max(1, Number(stage.min_success || 1));
+    if (outputs.length < minSuccess) {
+      throw new Error(
+        `parallel stage "${stage.id}" produced ${outputs.length}/${roles.length} successful outputs (min_success=${minSuccess})`
+      );
+    }
     appendThread(task, 'tiger', `stage ${stage.id} completed with ${outputs.length} parallel outputs`);
     task.next_agent = stage.next ? stageRef(stage.next) : 'tiger';
     task.status = 'pending';
@@ -448,17 +504,49 @@ async function runWorkerTurn(agentName) {
   let { task, filePath } = claim;
   try {
     task = await processWorkerTask(agentName, task);
+    clearRetryAttempts(task, 'worker', agentName);
     const out = releaseTask(task, filePath, task.status === 'failed' ? 'failed' : 'pending');
     return { ok: true, idle: false, agent: agentName, task: out.task };
   } catch (err) {
-    appendThread(task, agentName, `error: ${err.message}`);
+    const errorMsg = String(err && err.message ? err.message : 'unknown error');
+    appendThread(task, agentName, `error: ${errorMsg}`);
+    const attempt = markRetryAttempt(task, 'worker', agentName);
+    const maxRetries = Math.max(0, Number(process.env.SWARM_STEP_MAX_RETRIES || swarmStepMaxRetries || 0));
+
+    if (attempt <= maxRetries) {
+      task.status = 'pending';
+      task.next_agent = agentName;
+      appendThread(task, 'tiger', `retry scheduled for ${agentName} (${attempt}/${maxRetries})`);
+      const out = releaseTask(task, filePath, 'pending');
+      return {
+        ok: true,
+        idle: false,
+        retrying: true,
+        agent: agentName,
+        error: errorMsg,
+        task: out.task
+      };
+    }
+
     if (!task.metadata || typeof task.metadata !== 'object') task.metadata = {};
     task.metadata.last_failed_agent = agentName;
-    task.metadata.last_error = String(err && err.message ? err.message : 'unknown error');
+    task.metadata.last_error = errorMsg;
+
+    if (swarmContinueOnError) {
+      appendThread(task, 'tiger', `continuing after ${agentName} failure (retries exhausted)`);
+      task.status = 'pending';
+      task.next_agent = 'tiger';
+      if (!task.result) {
+        task.result = `Task completed with degraded path: ${agentName} failed after ${attempt - 1} retries. Last error: ${errorMsg}`;
+      }
+      const out = releaseTask(task, filePath, 'pending');
+      return { ok: true, idle: false, degraded: true, agent: agentName, error: errorMsg, task: out.task };
+    }
+
     task.status = 'failed';
     task.next_agent = 'tiger';
     const out = releaseTask(task, filePath, 'failed');
-    return { ok: false, idle: false, agent: agentName, error: err.message, task: out.task };
+    return { ok: false, idle: false, agent: agentName, error: errorMsg, task: out.task };
   }
 }
 
@@ -525,9 +613,58 @@ async function runTaskToTiger(taskId, opts = {}) {
       const stage = getStageById(architecture, stageId);
       if (!stage) return { ok: false, task, error: `Unknown stage: ${stageId}` };
       if (onProgress) onProgress({ phase: 'worker_start', agent: stage.id, task });
-      const updated = await runArchitectureStage(task, architecture, stage);
-      saveTaskInPlace(filePath, updated);
-      if (onProgress) onProgress({ phase: 'worker_done', agent: stage.id, task: updated, turn: { ok: true } });
+      try {
+        const updated = await runArchitectureStage(task, architecture, stage);
+        clearRetryAttempts(updated, 'stage', stageId);
+        saveTaskInPlace(filePath, updated);
+        if (onProgress) onProgress({ phase: 'worker_done', agent: stage.id, task: updated, turn: { ok: true } });
+      } catch (err) {
+        const errorMsg = String(err && err.message ? err.message : 'unknown error');
+        appendThread(task, 'tiger', `stage ${stageId} error: ${errorMsg}`);
+        const attempt = markRetryAttempt(task, 'stage', stageId);
+        const maxRetries = Math.max(0, Number(process.env.SWARM_STEP_MAX_RETRIES || swarmStepMaxRetries || 0));
+
+        if (attempt <= maxRetries) {
+          task.status = 'pending';
+          task.next_agent = stageRef(stageId);
+          appendThread(task, 'tiger', `retry scheduled for stage ${stageId} (${attempt}/${maxRetries})`);
+          saveTaskInPlace(filePath, task);
+          if (onProgress) {
+            onProgress({
+              phase: 'worker_done',
+              agent: stage.id,
+              task,
+              turn: { ok: true, retrying: true, error: errorMsg }
+            });
+          }
+          continue;
+        }
+
+        if (swarmContinueOnError) {
+          const fallbackNext = stage.fail_next || stage.next || 'tiger';
+          task.status = 'pending';
+          task.next_agent = fallbackNext === 'tiger' ? 'tiger' : stageRef(fallbackNext);
+          appendThread(task, 'tiger', `continuing after stage ${stageId} failure (retries exhausted)`);
+          if (!task.result && task.next_agent === 'tiger') {
+            task.result = `Task completed with degraded path: stage ${stageId} failed after ${attempt - 1} retries. Last error: ${errorMsg}`;
+          }
+          saveTaskInPlace(filePath, task);
+          if (onProgress) {
+            onProgress({
+              phase: 'worker_done',
+              agent: stage.id,
+              task,
+              turn: { ok: true, degraded: true, error: errorMsg }
+            });
+          }
+          continue;
+        }
+
+        task.status = 'failed';
+        task.next_agent = 'tiger';
+        saveTaskInPlace(filePath, task);
+        return { ok: false, task, error: errorMsg };
+      }
       continue;
     }
 

package/src/telegram/bot.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const TelegramBot = require('node-telegram-bot-api');
-const { telegramBotToken } = require('../config');
+const { telegramBotToken, swarmEnabled } = require('../config');
 const { handleMessage } = require('../agent/mainAgent');
 const tokenManager = require('../tokenManager');
 const { getProvider } = require('../apiProviders');
@@ -170,7 +170,7 @@ function startTelegramBot() {
   ensureSwarmLayout();
   ensureSwarmConfigLayout();
   const bot = new TelegramBot(telegramBotToken, { polling: true });
-  let swarmEnabled = true;
+  let swarmRoutingEnabled = swarmEnabled;
 
   // Register commands so Telegram shows the list when user types /
   bot.setMyCommands([
@@ -228,16 +228,16 @@ function startTelegramBot() {
     if (text.startsWith('/swarm')) {
       const arg = text.slice(6).trim().toLowerCase();
       if (!arg) {
-        await safeSend(bot, chatId, `🐯 Swarm is currently *${swarmEnabled ? 'ON' : 'OFF'}*.\nUse \`/swarm on\` or \`/swarm off\`.`, MD);
+        await safeSend(bot, chatId, `🐯 Swarm is currently *${swarmRoutingEnabled ? 'ON' : 'OFF'}*.\nUse \`/swarm on\` or \`/swarm off\`.`, MD);
         return;
       }
       if (arg === 'on') {
-        swarmEnabled = true;
+        swarmRoutingEnabled = true;
         await safeSend(bot, chatId, '✅ Swarm routing is now *ON*', MD);
         return;
       }
       if (arg === 'off') {
-        swarmEnabled = false;
+        swarmRoutingEnabled = false;
         await safeSend(bot, chatId, '✅ Swarm routing is now *OFF*\\.\nNew messages will go to the regular Tiger agent\\.', { parse_mode: 'MarkdownV2' });
         return;
       }
@@ -509,7 +509,7 @@ function startTelegramBot() {
     try {
       await safeSendTyping(bot, chatId);
       typingTimer = setInterval(() => safeSendTyping(bot, chatId), 4500);
-      if (!swarmEnabled) {
+      if (!swarmRoutingEnabled) {
         const reply = await handleMessage({ platform: 'telegram', userId, text });
         clearInterval(typingTimer);
         await safeSend(bot, chatId, reply);

package/src/telegram/supervisor.js

@@ -11,10 +11,15 @@ const logsDir = path.resolve(runtimeDir, 'logs');
 const botLogPath = path.resolve(logsDir, 'telegram.out.log');
 const supervisorPidPath = path.resolve(runtimeDir, 'tiger-telegram.pid');
 const workerPidPath = path.resolve(runtimeDir, 'tiger-telegram-worker.pid');
+const workerHeartbeatPath = path.resolve(runtimeDir, 'tiger-telegram-worker.heartbeat');
 const restartDelayMs = 5000;
+const heartbeatCheckMs = 60 * 1000;
+const heartbeatTimeoutMs = 5 * 60 * 1000;
 
 let worker = null;
 let stopping = false;
+let heartbeatTimer = null;
+let restartPending = false;
 
 function appendLog(line) {
   fs.appendFileSync(botLogPath, `[${new Date().toISOString()}] ${line}\n`, 'utf8');
@@ -24,6 +29,46 @@ function writeBufferToLog(buffer) {
   fs.appendFileSync(botLogPath, buffer);
 }
 
+function getHeartbeatAgeMs() {
+  if (!fs.existsSync(workerHeartbeatPath)) return Number.POSITIVE_INFINITY;
+  const raw = fs.readFileSync(workerHeartbeatPath, 'utf8').trim();
+  const ts = Number(raw);
+  if (!Number.isFinite(ts) || ts <= 0) return Number.POSITIVE_INFINITY;
+  return Date.now() - ts;
+}
+
+function scheduleRestart(reason) {
+  if (stopping || restartPending) return;
+  restartPending = true;
+  appendLog(`${reason}, restarting in 5s`);
+  setTimeout(() => {
+    restartPending = false;
+    startWorker();
+  }, restartDelayMs);
+}
+
+function stopWorker(reason) {
+  if (!worker || !worker.pid) return;
+  appendLog(reason);
+  try {
+    process.kill(worker.pid, 'SIGTERM');
+  } catch (err) {
+    // Worker may already be dead.
+  }
+}
+
+function startHeartbeatMonitor() {
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  heartbeatTimer = setInterval(() => {
+    if (stopping || !worker || !worker.pid) return;
+    const ageMs = getHeartbeatAgeMs();
+    if (ageMs > heartbeatTimeoutMs) {
+      stopWorker(`heartbeat stale (${Math.round(ageMs / 1000)}s > ${Math.round(heartbeatTimeoutMs / 1000)}s), force restarting worker`);
+      scheduleRestart('worker restart requested by heartbeat watchdog');
+    }
+  }, heartbeatCheckMs);
+}
+
 function startWorker() {
   if (stopping) return;
 
@@ -35,7 +80,9 @@ function startWorker() {
   });
 
   fs.writeFileSync(workerPidPath, `${worker.pid}\n`, 'utf8');
+  fs.writeFileSync(workerHeartbeatPath, `${Date.now()}\n`, 'utf8');
   appendLog(`worker started (PID ${worker.pid})`);
+  startHeartbeatMonitor();
 
   if (worker.stdout) {
     worker.stdout.on('data', writeBufferToLog);
@@ -47,8 +94,7 @@ function startWorker() {
   worker.on('exit', (code, signal) => {
     if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
     if (stopping) return;
-    appendLog(`worker exited (code=${code}, signal=${signal || 'none'}), restarting in 5s`);
-    setTimeout(startWorker, restartDelayMs);
+    scheduleRestart(`worker exited (code=${code}, signal=${signal || 'none'})`);
   });
 }
 
@@ -65,7 +111,12 @@ function shutdown(signal) {
     }
   }
 
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
   if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+  if (fs.existsSync(workerHeartbeatPath)) fs.unlinkSync(workerHeartbeatPath);
   if (fs.existsSync(supervisorPidPath)) fs.unlinkSync(supervisorPidPath);
   process.exit(0);
 }