@yemi33/minions 0.1.1936 → 0.1.1938

package/engine/cc-worker-pool.js

@@ -252,17 +252,19 @@ class Worker {
           try { this.inflight.onChunk(text); } catch { /* swallow */ }
         }
       } else if (update.sessionUpdate === 'tool_call' && this.inflight.onToolUse) {
-        // ACP `tool_call` (status: pending, fired at invocation time) is the
-        // pool's equivalent of Claude's tool_use event. We map kinds to
-        // Claude-style tool names so the dashboard's existing
-        // formatToolSummary (Bash → "$ <cmd>", Read → "Reading <path>", etc.)
-        // works unchanged. Status updates (`tool_call_update`, status:
-        // completed) carry the result and are ignored here — surfacing
-        // results too would double the chip count without adding info the
-        // user can act on.
+        // ACP `tool_call` (pending) → Claude-style {name, input} via
+        // _mapAcpToolCallToToolUse so the dashboard's formatToolSummary
+        // formatters (Bash → "$ <cmd>", etc.) work unchanged.
         const mapped = _mapAcpToolCallToToolUse(update);
         if (mapped) {
-          try { this.inflight.onToolUse(mapped.name, mapped.input); }
+          try { this.inflight.onToolUse(mapped.name, mapped.input, update.toolCallId); }
+          catch { /* swallow */ }
+        }
+      } else if (update.sessionUpdate === 'tool_call_update' && this.inflight.onToolUpdate) {
+        // Terminal-state updates only (completed/failed). In-progress updates
+        // exist in the ACP spec but add chip churn without actionable info.
+        if (update.status === 'completed' || update.status === 'failed') {
+          try { this.inflight.onToolUpdate(update.toolCallId, update.status); }
           catch { /* swallow */ }
         }
       }
@@ -290,7 +292,7 @@ class Worker {
 
   // ── Stream a single turn ───────────────────────────────────────────────
   stream(promptText, opts = {}) {
-    const { onChunk, onToolUse, onDone, onError, signal, systemPromptText } = opts;
+    const { onChunk, onToolUse, onToolUpdate, onDone, onError, signal, systemPromptText } = opts;
     if (this.killed) {
       const err = new Error('cc-worker-pool: tab is closed');
       if (onError) try { onError(err); } catch { /* swallow */ }
@@ -319,6 +321,7 @@ class Worker {
       sessionId: this.sessionId,
       onChunk,
       onToolUse,
+      onToolUpdate,
       onDone,
       onError,
       signal,
@@ -449,31 +452,44 @@ function _mapAcpToolCallToToolUse(update) {
   const rawInput = (update.rawInput && typeof update.rawInput === 'object') ? update.rawInput : {};
   const kind = String(update.kind || '').toLowerCase();
   const title = update.title || '';
-  // For kinds with a clear Claude-tool equivalent, use that name + raw input.
+
+  // Field-name normalization: Copilot ACP and Claude tool_use use different
+  // keys for the same concept (Copilot `path`, Claude `file_path`). Normalize
+  // here so the dashboard's formatToolSummary — written against Claude's
+  // names — produces the same chip text on both runtimes.
+  const filePath = rawInput.file_path || rawInput.path || rawInput.filePath || '';
+
+  // Pattern (Grep) — Copilot uses `paths` (plural) for the search scope where
+  // Claude's Grep takes `path`.
+  if (typeof rawInput.pattern === 'string') {
+    return {
+      name: 'Grep',
+      input: { pattern: rawInput.pattern, path: rawInput.paths || rawInput.path || '.' },
+    };
+  }
+
   switch (kind) {
     case 'execute':
       return { name: 'Bash', input: rawInput };
     case 'read':
-      return { name: 'Read', input: rawInput };
+      // ACP overloads `read` for both file-view and grep — the pattern check
+      // above already handled grep, so this branch is the file-view case.
+      return { name: 'Read', input: { file_path: filePath } };
     case 'edit':
-      return { name: 'Edit', input: rawInput };
-    case 'search': {
-      // Heuristic: Grep needs a pattern; Glob needs a glob pattern.
-      // ACP doesn't distinguish, so prefer Grep when a `path` hint is present
-      // (matches the dashboard's Grep formatter "Searching <pat> in <path>").
-      const isGrep = typeof rawInput.path === 'string' || typeof rawInput.regex === 'string';
-      return { name: isGrep ? 'Grep' : 'Glob', input: rawInput };
-    }
+      return { name: 'Edit', input: { file_path: filePath } };
+    case 'search':
+      // Pattern check above handled the grep case; arriving here means glob.
+      return { name: 'Glob', input: rawInput };
     case 'fetch':
       return { name: 'WebFetch', input: rawInput };
     case 'think':
-      // No equivalent Claude tool; show the title so the user sees Copilot's
-      // own description of what it's thinking about.
       return { name: title || 'Think', input: rawInput };
     default:
-      // Fallback: show ACP's title and pass rawInput through. The dashboard's
-      // default formatter renders this as `<title>(<key>: <val>)`.
-      return { name: title || kind || 'Tool', input: rawInput };
+      // Unknown kind — use ACP's human-readable title as the chip label and
+      // drop rawInput so formatToolSummary's default branch shows just the
+      // title (avoids `<title>(<key>: <val>)` clutter when the input shape
+      // is unfamiliar).
+      return { name: title || kind || 'Tool', input: {} };
   }
 }
 
@@ -552,6 +568,18 @@ function closeTab(tabId) {
   worker.close();
 }
 
+// Cancel the currently in-flight prompt on this tab without killing the
+// worker. Sends ACP `session/cancel` so the remote daemon stops generating;
+// the warm process + initialized MCP servers + session state are preserved
+// so the next prompt skips the ~7-8 s cold-spawn cost. No-op if the tab has
+// no worker or no inflight prompt.
+function cancelInflight(tabId) {
+  const worker = _tabs.get(tabId);
+  if (!worker || worker.killed || !worker.inflight) return false;
+  try { worker.cancel(); } catch { /* swallow */ }
+  return true;
+}
+
 function shutdown() {
   for (const worker of _tabs.values()) {
     try { worker.close(); } catch { /* swallow */ }
@@ -583,6 +611,7 @@ function _reapIdleTabs() {
 module.exports = {
   getSession,
   closeTab,
+  cancelInflight,
   shutdown,
   // Exposed for unit tests; engine code MUST go through the public API.
   _internals,

package/engine/cli.js

@@ -731,19 +731,6 @@ const commands = {
       }
     }, 1000);
 
-    // Teams inbox poll timer — process incoming Teams messages through CC
-    const teams = require('./teams');
-    const teamsInboxInterval = config.teams?.inboxPollInterval ?? shared.ENGINE_DEFAULTS.teams.inboxPollInterval;
-    const teamsInboxTimer = teams.isTeamsEnabled() ? setInterval(() => {
-      try {
-        const ctrl = getControl();
-        if (ctrl.state !== 'running') return;
-        teams.processTeamsInbox().catch(err => {
-          shared.log('warn', `Teams inbox poll error: ${err.message}`);
-        });
-      } catch {}
-    }, teamsInboxInterval) : null;
-
     console.log(`Tick interval: ${interval / 1000}s | Max concurrent: ${config.engine?.maxConcurrent || 5}`);
     console.log('Press Ctrl+C to stop');
 
@@ -804,7 +791,6 @@ const commands = {
       console.log(`\n${signal} received — initiating graceful shutdown...`);
       clearInterval(tickTimer);
       clearInterval(fastPollTimer);
-      if (teamsInboxTimer) clearInterval(teamsInboxTimer);
       for (const f of _watchedFiles) { try { fs.unwatchFile(f); } catch { /* cleanup */ } }
       const stoppingAt = e.ts();
       const stoppingWrite = markControlStoppingForOwner(controlOwner, stoppingAt);

package/engine/github.js

@@ -646,14 +646,6 @@ async function pollPrStatus(config) {
         pr.reviewStatus = newReviewStatus;
         updated = true;
         shared.trackReviewMetric(pr, newReviewStatus, config);
-        if (newReviewStatus === 'approved') {
-          // Teams notification for PR approval — non-blocking, edge-triggered (only on transition)
-          try {
-            const teams = require('./teams');
-            const prFilePath = shared.projectPrPath(project);
-            teams.teamsNotifyPrEvent(pr, 'pr-approved', project, prFilePath).catch(() => {});
-          } catch {}
-        }
       }
     }
 
@@ -717,15 +709,6 @@ async function pollPrStatus(config) {
             }
           }
           updated = true;
-
-          if (buildStatus === 'failing') {
-            // Teams notification for build failure — non-blocking
-            try {
-              const teams = require('./teams');
-              const prFilePath = shared.projectPrPath(project);
-              teams.teamsNotifyPrEvent(pr, 'build-failed', project, prFilePath).catch(() => {});
-            } catch {}
-          }
         }
         if (buildStatus === 'failing') {
           if (buildFailReason && pr.buildFailReason !== buildFailReason) {

package/engine/lifecycle.js

@@ -377,26 +377,11 @@ function checkPlanCompletion(meta, config) {
       }
     }
 
-    if (createdAny) {
-      try {
-        const teams = require('./teams');
-        teams.teamsNotifyPlanEvent({ name: plan.plan_summary || planFile, file: planFile }, 'verify-created').catch(() => {});
-      } catch {}
-    }
     if (reopenedAny) log('info', `Plan ${planFile}: re-opened verify WI(s) for modified plan`);
   }
 
   // Archive deferred until verify completes
 
-  // Teams notification for plan completion — non-blocking
-  try {
-    const teams = require('./teams');
-    teams.teamsNotifyPlanEvent({
-      name: plan.plan_summary || planFile, file: planFile, project: plan.project,
-      doneCount: doneItems.length, totalCount: planFeatureIds.size,
-    }, 'plan-completed').catch(() => {});
-  } catch {}
-
   log('info', `PRD ${planFile} completed: ${doneItems.length} done, ${failedItems.length} failed, runtime ${runtimeMin}m`);
   return true;
 }
@@ -2271,14 +2256,6 @@ async function handlePostMerge(pr, project, config, newStatus) {
     });
   }
 
-  // Teams PR lifecycle notification — non-blocking
-  try {
-    const teams = require('./teams');
-    const prEvent = newStatus === PR_STATUS.MERGED ? 'pr-merged' : 'pr-abandoned';
-    const prFilePath = project ? projectPrPath(project) : null;
-    teams.teamsNotifyPrEvent(pr, prEvent, project, prFilePath).catch(() => {});
-  } catch {}
-
   log('info', `Post-merge hooks completed for ${pr.id}`);
 }
 
@@ -3719,12 +3696,6 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const metricsResult = isAutoRetry ? 'retry' : finalResult;
   updateMetrics(agentId, dispatchItem, metricsResult, taskUsage, prsCreatedCount, model);
 
-  // Teams notification — non-blocking
-  try {
-    const teams = require('./teams');
-    teams.teamsNotifyCompletion(dispatchItem, finalResult, agentId).catch(() => {});
-  } catch {}
-
   return { resultSummary, taskUsage, autoRecovered, structuredCompletion, completionContractFailure, agentReportedFailure, agentRetryable };
 }
 

package/engine/preflight.js

@@ -580,25 +580,6 @@ function doctor(minionsHome) {
     } else {
       runtimeResults.push({ name: 'Agents configured', ok: false, message: 'no agents in config.json — re-run: minions init (see docs/auto-discovery.md)' });
     }
-
-    // Check Teams integration — supports client secret OR certificate auth
-    const teams = config.teams;
-    if (teams && teams.enabled === true) {
-      const hasSecret = !!teams.appId && !!teams.appPassword;
-      const hasCert = !!teams.appId && !!teams.certPath && !!teams.privateKeyPath && !!teams.tenantId;
-      if (!hasSecret && !hasCert) {
-        const missing = [
-          !teams.appId && 'appId',
-          !teams.appPassword && !teams.certPath && 'appPassword or certPath+privateKeyPath+tenantId',
-        ].filter(Boolean).join(', ');
-        runtimeResults.push({ name: 'Teams integration', ok: 'warn', message: `enabled but missing: ${missing} — see docs/teams-setup.md` });
-      } else {
-        const authMode = hasCert ? 'certificate' : 'client secret';
-        runtimeResults.push({ name: 'Teams integration', ok: true, message: `configured (${authMode})` });
-      }
-    } else {
-      runtimeResults.push({ name: 'Teams integration', ok: 'warn', message: 'disabled — see docs/teams-setup.md' });
-    }
   } catch {
     runtimeResults.push({ name: 'Config', ok: false, message: `missing or invalid — run: minions init (see docs/distribution.md)` });
   }

package/engine/shared.js

@@ -1147,19 +1147,6 @@ const ENGINE_DEFAULTS = {
   // knows which subkeys to flag as deprecated. Do not consume `claude.*` in new code — use the runtime
   // adapter system (engine/runtimes/) and the resolveAgent*/resolveCc* helpers instead.
   _deprecatedConfigClaudeFields: ['binary', 'outputFormat', 'allowedTools', 'maxTurns', 'effort', 'budgetCap'],
-  // Teams integration — config.teams shape: { enabled, appId, appPassword, certPath, privateKeyPath, tenantId, notifyEvents, ccMirror, inboxPollInterval }
-  // Auth modes: (1) appId + appPassword (client secret), or (2) appId + certPath + privateKeyPath + tenantId (certificate)
-  teams: {
-    enabled: false,
-    appId: '',
-    appPassword: '',
-    certPath: '',          // PEM certificate file path (certificate auth)
-    privateKeyPath: '',    // PEM private key file path (certificate auth)
-    tenantId: '',          // Azure AD tenant ID (required for certificate auth)
-    notifyEvents: ['pr-merged', 'agent-completed', 'plan-completed', 'agent-failed'],
-    ccMirror: true,
-    inboxPollInterval: 15000,
-  },
 };
 
 // ─── Runtime Fleet Resolution (P-3b8e5f1d) ──────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1936",
+  "version": "0.1.1938",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"
@@ -63,9 +63,6 @@
   "devDependencies": {
     "@playwright/test": "^1.58.2"
   },
-  "dependencies": {
-    "botbuilder": "4.23.3"
-  },
   "publishConfig": {
     "access": "public"
   }

package/docs/teams-production.md

@@ -1,370 +0,0 @@
-# Teams Production Endpoint Migration
-
-> Last verified: 2026-05-12. `botbuilder` dependency confirmed in `package.json` (4.23.3); `/api/bot` route confirmed in `dashboard.js` (`handleTeamsBot`).
-
-Guide for migrating the Minions Teams bot from a Dev Tunnel to a stable public HTTPS endpoint for production use. Choose one of the three deployment options below based on your infrastructure.
-
-**Key fact:** The Azure Bot messaging endpoint URL can be changed at any time in the Azure Portal — it takes effect immediately. No bot reinstallation is needed in Teams. This means you can switch between Dev Tunnel and production endpoints freely.
-
-**Prerequisites:**
-
-- A working Teams integration via Dev Tunnel (see [docs/teams-setup.md](teams-setup.md))
-- Azure CLI installed (`az --version`) for Options 1 and 2
-- A public-facing server or VM for Option 3
-
----
-
-## Option 1: Azure App Service
-
-Deploy the Minions dashboard as an Azure App Service with a stable FQDN.
-
-### Steps
-
-1. **Create an App Service Plan** (skip if you have one):
-
-   ```bash
-   az appservice plan create \
-     --name minions-plan \
-     --resource-group rg-minions \
-     --sku B1 \
-     --is-linux
-   ```
-
-2. **Create the Web App:**
-
-   ```bash
-   az webapp create \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --plan minions-plan \
-     --runtime "NODE:20-lts"
-   ```
-
-   This creates a publicly accessible URL: `https://minions-dashboard.azurewebsites.net`
-
-3. **Configure environment variables:**
-
-   ```bash
-   az webapp config appsettings set \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --settings \
-       PORT=8080 \
-       NODE_ENV=production
-   ```
-
-   > Azure App Service routes external port 443 (HTTPS) to your app's internal port (default 8080). Set `PORT=8080` so the dashboard listens on the expected port.
-
-4. **Deploy the code:**
-
-   ```bash
-   # From the minions repository root
-   az webapp deploy \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --src-path . \
-     --type zip
-   ```
-
-   Alternatively, configure continuous deployment from your Git repository:
-
-   ```bash
-   az webapp deployment source config \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --repo-url https://github.com/your-org/minions \
-     --branch master \
-     --manual-integration
-   ```
-
-5. **Copy `config.json` to the App Service.** The simplest approach is to use the Kudu console or App Service Editor to upload your `config.json` to the application root. Alternatively, mount an Azure File Share containing your config.
-
-6. **Update the Azure Bot messaging endpoint:**
-
-   - Open the [Azure Portal](https://portal.azure.com) > your Azure Bot resource > **Configuration**.
-   - Change the **Messaging endpoint** to:
-     ```
-     https://minions-dashboard.azurewebsites.net/api/bot
-     ```
-   - Click **Apply**. The change takes effect immediately.
-
-### Verify
-
-1. Open `https://minions-dashboard.azurewebsites.net/api/routes` in a browser — you should see the API route list.
-2. In the Azure Bot resource, click **Test in Web Chat** and send a message.
-3. Send a message in Teams to the bot — confirm it receives and responds.
-
-### Rollback
-
-To revert to Dev Tunnel:
-
-1. Start your local Dev Tunnel: `devtunnel host -p 7331 --allow-anonymous`
-2. Update the Azure Bot messaging endpoint back to your tunnel URL: `https://<tunnel>.devtunnels.ms/api/bot`
-3. Click **Apply**. Traffic returns to your local machine immediately.
-
----
-
-## Option 2: Azure Container App
-
-Containerize the dashboard and deploy to Azure Container Apps with a stable FQDN.
-
-### Steps
-
-1. **Create a Dockerfile** in the repository root:
-
-   ```dockerfile
-   FROM node:20-slim
-   WORKDIR /app
-   COPY package*.json ./
-   RUN npm ci --omit=dev 2>/dev/null || true
-   COPY . .
-   EXPOSE 7331
-   CMD ["node", "dashboard.js"]
-   ```
-
-   > Minions ships with `botbuilder` as its only runtime dependency (declared in `package.json`); other operations rely on Node.js built-ins, so `npm ci` is a fast install.
-
-2. **Build and push to Azure Container Registry:**
-
-   ```bash
-   # Create a container registry (skip if you have one)
-   az acr create \
-     --name minionsacr \
-     --resource-group rg-minions \
-     --sku Basic
-
-   # Build and push
-   az acr build \
-     --registry minionsacr \
-     --image minions-dashboard:latest .
-   ```
-
-3. **Create a Container Apps environment** (skip if you have one):
-
-   ```bash
-   az containerapp env create \
-     --name minions-env \
-     --resource-group rg-minions \
-     --location eastus
-   ```
-
-4. **Deploy the container:**
-
-   ```bash
-   az containerapp create \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --environment minions-env \
-     --image minionsacr.azurecr.io/minions-dashboard:latest \
-     --registry-server minionsacr.azurecr.io \
-     --target-port 7331 \
-     --ingress external \
-     --min-replicas 1 \
-     --max-replicas 1 \
-     --env-vars NODE_ENV=production
-   ```
-
-   > Use `--min-replicas 1 --max-replicas 1` because the Minions engine uses file-based state that doesn't support multiple replicas.
-
-5. **Get the FQDN:**
-
-   ```bash
-   az containerapp show \
-     --name minions-dashboard \
-     --resource-group rg-minions \
-     --query "properties.configuration.ingress.fqdn" \
-     --output tsv
-   ```
-
-   This returns something like: `minions-dashboard.happyfield-abc123.eastus.azurecontainerapps.io`
-
-6. **Update the Azure Bot messaging endpoint:**
-
-   - Open the [Azure Portal](https://portal.azure.com) > your Azure Bot resource > **Configuration**.
-   - Change the **Messaging endpoint** to:
-     ```
-     https://minions-dashboard.happyfield-abc123.eastus.azurecontainerapps.io/api/bot
-     ```
-   - Click **Apply**. The change takes effect immediately.
-
-### Verify
-
-1. Open `https://<your-fqdn>/api/routes` in a browser.
-2. Test via Azure Bot **Test in Web Chat**.
-3. Send a message in Teams — confirm end-to-end flow works.
-
-### Rollback
-
-To revert to Dev Tunnel:
-
-1. Start your local Dev Tunnel: `devtunnel host -p 7331 --allow-anonymous`
-2. Update the Azure Bot messaging endpoint back to your tunnel URL.
-3. Click **Apply**. Immediate switchover.
-
-Optionally stop the container to save costs:
-
-```bash
-az containerapp update \
-  --name minions-dashboard \
-  --resource-group rg-minions \
-  --min-replicas 0 --max-replicas 0
-```
-
----
-
-## Option 3: Reverse Proxy (nginx / Caddy)
-
-For servers with a public IP address or an existing reverse proxy setup.
-
-### Steps (Caddy — recommended for simplicity)
-
-Caddy automatically provisions and renews TLS certificates via Let's Encrypt.
-
-1. **Install Caddy:**
-
-   ```bash
-   # Debian/Ubuntu
-   sudo apt install -y caddy
-
-   # macOS
-   brew install caddy
-   ```
-
-2. **Configure Caddy.** Create or edit `/etc/caddy/Caddyfile`:
-
-   ```
-   minions.yourdomain.com {
-     reverse_proxy localhost:7331
-   }
-   ```
-
-   > Replace `minions.yourdomain.com` with your actual domain. Ensure a DNS A record points this domain to your server's public IP.
-
-3. **Start Caddy:**
-
-   ```bash
-   sudo systemctl enable --now caddy
-   ```
-
-   Caddy automatically obtains a Let's Encrypt TLS certificate for your domain.
-
-4. **Start the Minions dashboard:**
-
-   ```bash
-   minions dash
-   ```
-
-   Or run it as a systemd service for persistence:
-
-   ```bash
-   # /etc/systemd/system/minions-dashboard.service
-   [Unit]
-   Description=Minions Dashboard
-   After=network.target
-
-   [Service]
-   Type=simple
-   User=your-user
-   WorkingDirectory=/path/to/minions
-   ExecStart=/usr/bin/node dashboard.js
-   Restart=on-failure
-
-   [Install]
-   WantedBy=multi-user.target
-   ```
-
-   ```bash
-   sudo systemctl enable --now minions-dashboard
-   ```
-
-5. **Update the Azure Bot messaging endpoint:**
-
-   - Open the Azure Portal > your Azure Bot resource > **Configuration**.
-   - Change the **Messaging endpoint** to:
-     ```
-     https://minions.yourdomain.com/api/bot
-     ```
-   - Click **Apply**. The change takes effect immediately.
-
-### Steps (nginx)
-
-1. **Install nginx and certbot:**
-
-   ```bash
-   sudo apt install -y nginx certbot python3-certbot-nginx
-   ```
-
-2. **Configure nginx.** Create `/etc/nginx/sites-available/minions`:
-
-   ```nginx
-   server {
-     listen 80;
-     server_name minions.yourdomain.com;
-
-     location / {
-       proxy_pass http://localhost:7331;
-       proxy_http_version 1.1;
-       proxy_set_header Upgrade $http_upgrade;
-       proxy_set_header Connection 'upgrade';
-       proxy_set_header Host $host;
-       proxy_set_header X-Real-IP $remote_addr;
-       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-       proxy_set_header X-Forwarded-Proto $scheme;
-     }
-   }
-   ```
-
-   ```bash
-   sudo ln -s /etc/nginx/sites-available/minions /etc/nginx/sites-enabled/
-   sudo nginx -t && sudo systemctl reload nginx
-   ```
-
-3. **Obtain a TLS certificate:**
-
-   ```bash
-   sudo certbot --nginx -d minions.yourdomain.com
-   ```
-
-   Certbot modifies the nginx config to add TLS and sets up auto-renewal.
-
-4. **Start the Minions dashboard** (same as Caddy option above).
-
-5. **Update the Azure Bot messaging endpoint** (same as Caddy option above).
-
-### Verify
-
-1. Open `https://minions.yourdomain.com/api/routes` in a browser — confirm the route list loads over HTTPS.
-2. Check the TLS certificate: `curl -vI https://minions.yourdomain.com 2>&1 | grep "SSL certificate"`.
-3. Test via Azure Bot **Test in Web Chat**.
-4. Send a message in Teams — confirm the bot responds.
-
-### Rollback
-
-To revert to Dev Tunnel:
-
-1. Start your local Dev Tunnel: `devtunnel host -p 7331 --allow-anonymous`
-2. Update the Azure Bot messaging endpoint back to your tunnel URL.
-3. Click **Apply**. Immediate switchover.
-
-The reverse proxy can remain running — it just won't receive Bot Framework traffic until the endpoint is pointed back.
-
----
-
-## Choosing an Option
-
-| Criteria | App Service | Container App | Reverse Proxy |
-|----------|-------------|---------------|---------------|
-| Setup complexity | Medium | Medium | Low (Caddy) / Medium (nginx) |
-| TLS management | Automatic | Automatic | Automatic (Caddy/certbot) |
-| Cost | ~$13/mo (B1) | Pay-per-use | Free (your server + Let's Encrypt) |
-| Custom domain | Supported | Supported | Required |
-| Scaling | Supported but not needed | Supported but not needed | Manual |
-| Best for | Azure-native teams | Container workflows | Existing servers |
-
-> **Note on replicas:** Minions uses file-based state (`engine/*.json`). Do not run multiple replicas — use exactly 1 instance. All three options above default to single-instance deployment.
-
-## Common Notes
-
-- **Endpoint changes are immediate.** When you update the messaging endpoint in the Azure Bot Configuration, it takes effect right away. No bot reinstallation, no downtime, no user-visible change in Teams.
-- **No deprecated webhooks.** This guide uses Azure Bot Framework exclusively. Do not use deprecated O365 Connector webhooks or Power Automate flows — they are being removed by Microsoft.
-- **Config portability.** The same `config.json` works across all environments. Just ensure the `teams.appId` and `teams.appPassword` are correct for the bot registration that points to your production URL.