@openhands/extensions 0.4.2 → 0.5.0

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.4.2"
+  ".": "0.5.0"
 }

package/automations/catalog/slack-channel-monitor.json

@@ -2,10 +2,10 @@
   "id": "slack-channel-monitor",
   "name": "Slack channel monitor",
   "category": "Team communication",
-  "description": "Watch Slack channels for @openhands mentions, open a conversation with the message context, and reply in the thread when the agent finishes.",
+  "description": "Watch Slack channels for @openhands mentions, open a conversation with the message context, reply when the agent finishes, and continue the same conversation from triggered Slack thread follow-ups.",
   "requiredIntegrationIds": ["slack"],
   "popularityRank": 92,
   "estimatedSetupMinutes": 7,
   "prompt": "/slack-monitor:poll",
-  "exampleImplementation": "Trigger: cron, every minute\nRequired secret: SLACK_BOT_TOKEN or SLACK_USER_TOKEN\n\n1. Poll up to 10 configured Slack channels for new messages since the last run.\n2. Match messages containing the trigger phrase (default: @openhands).\n3. React with 👀 and start an OpenHands conversation with the message and recent channel context.\n4. Post a thread reply with a link to the conversation.\n5. Forward subsequent thread replies to the running conversation and post the agent's response when done."
+  "exampleImplementation": "Trigger: cron, every minute\nRequired secret: SLACK_BOT_TOKEN or SLACK_USER_TOKEN\n\n1. Poll up to 10 configured Slack channels for new messages since the last run.\n2. Match messages containing the trigger phrase (default: @openhands).\n3. React with 👀 and start an OpenHands conversation with the message and recent channel context.\n4. Post a thread reply with a link to the conversation, then post the agent response when done.\n5. Keep the thread in a short follow-up watch window and forward only replies that repeat the trigger phrase to the same conversation, with per-thread backoff for quiet threads."
 }

package/integrations/catalog/github.json

@@ -12,7 +12,6 @@
     "code"
   ],
   "popularityRank": 100,
-  "installHint": "Requires Docker because the legacy npm package was deprecated upstream.",
   "kind": "mcp",
   "defaultConnectionOptionId": "api",
   "connectionOptions": [
@@ -20,31 +19,16 @@
       "id": "api",
       "provider": "mcp",
       "transport": {
-        "kind": "stdio",
-        "serverName": "github",
-        "command": "docker",
-        "args": [
-          "run",
-          "-i",
-          "--rm",
-          "-e",
-          "GITHUB_PERSONAL_ACCESS_TOKEN",
-          "ghcr.io/github/github-mcp-server"
-        ],
-        "envFields": [
-          {
-            "key": "GITHUB_PERSONAL_ACCESS_TOKEN",
-            "label": "Personal access token",
-            "type": "password",
-            "placeholder": "github_pat_...",
-            "required": true,
-            "helperText": "Classic or fine-grained personal access token from GitHub settings.",
-            "helperLink": "https://github.com/settings/tokens"
-          }
-        ]
+        "kind": "shttp",
+        "url": "https://api.githubcopilot.com/mcp/"
       },
       "auth": {
-        "strategy": "api_key"
+        "strategy": "api_key",
+        "credentialLabel": "Personal access token",
+        "credentialPlaceholder": "github_pat_...",
+        "credentialHelp": "Classic or fine-grained personal access token from GitHub settings.",
+        "credentialSecretName": "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "saveCredentialAsSecretByDefault": true
       }
     }
   ]

package/integrations/index.d.ts

@@ -59,6 +59,8 @@ export interface IntegrationAuthConfig {
   credentialLabel?: string;
   credentialPlaceholder?: string;
   credentialHelp?: string;
+  credentialSecretName?: string;
+  saveCredentialAsSecretByDefault?: boolean;
   apiKeyHeaderName?: string;
   apiKeyOptional?: boolean;
   oauth?: IntegrationOAuthConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openhands/extensions",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Public OpenHands extension catalogs for skills, plugins, integrations, and automation templates.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "extensions"
-version = "0.4.2"
+version = "0.5.0"
 description = "OpenHands extensions, plugins, and skills"
 requires-python = ">=3.12"
 

package/skills/index.js

@@ -398,7 +398,7 @@ export const SKILLS_CATALOG = [
     "triggers": [
       "/slack-monitor:poll"
     ],
-    "content": "# Slack Channel Monitor\n\nCreate a cron automation that polls up to 10 Slack channels every minute.\nWhen a message containing the **trigger phrase** (default: `@openhands`) is\ndetected it:\n\n1. Adds a 👀 reaction to the triggering message.\n2. Opens an OpenHands conversation with the message and recent channel context.\n3. Posts a reply in the Slack thread with a link to the conversation.\n\nOn every subsequent run:\n- Replies in the thread are forwarded to the running conversation.\n- When the conversation finishes (or errors), the agent's final response is\n  posted back to the Slack thread.\n\n> **Local mode only.** This automation targets the local OpenHands setup\n> (`dev:automation` stack). A cloud/webhook-based variant is out of scope here.\n\n---\n\n## Prerequisites\n\n### Required secrets\n\nVerify that at least one of the following secrets is set in\n**OpenHands Settings → Secrets** before proceeding:\n\n| Secret name | Token type | Minimum scopes |\n|---|---|---|\n| `SLACK_BOT_TOKEN` | Bot (`xoxb-…`) | `channels:history`, `channels:read`, `reactions:write`, `chat:write` |\n| `SLACK_USER_TOKEN` | User (`xoxp-…`) | Same as bot, plus `search:read` for multi-channel efficiency |\n\nCheck with:\n```bash\n# For bot token:\ncurl -s https://slack.com/api/auth.test -H \"Authorization: Bearer $SLACK_BOT_TOKEN\" \\\n  | python3 -c \"import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))\"\n\n# For user token:\ncurl -s https://slack.com/api/auth.test -H \"Authorization: Bearer $SLACK_USER_TOKEN\" \\\n  | python3 -c \"import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))\"\n```\n\nIf neither token is present, inform the user and stop  -  the automation cannot\nfunction without Slack credentials.\n\n### Optional secret\n\n| Secret name | Default | Purpose |\n|---|---|---|\n| `OPENHANDS_URL` | `http://localhost:8000` | Base URL used to build conversation links posted in Slack |\n\n---\n\n## Setup Workflow\n\nFollow these steps in order.\n\n### Step 1  -  Collect channels\n\nAsk the user: *\"Which Slack channels should be monitored? You can provide\nchannel names (e.g. `#general`) or IDs (e.g. `C0123456789`).\"*\n\n**If the user provides channel names**, resolve them to IDs:\n\n```bash\nSLACK_TOKEN=\"${SLACK_BOT_TOKEN:-$SLACK_USER_TOKEN}\"\ncurl -s \"https://slack.com/api/conversations.list?types=public_channel,private_channel&limit=200&exclude_archived=true\" \\\n  -H \"Authorization: Bearer $SLACK_TOKEN\" \\\n  | python3 -c \"\nimport json, sys\ndata = json.load(sys.stdin)\nif not data.get('ok'):\n    print('ERROR:', data.get('error'))\n    exit(1)\nnames = set(n.lstrip('#') for n in ['CHANNEL_NAMES_HERE'.split(',')])\nfor ch in data.get('channels', []):\n    if ch['name'] in names:\n        print(f\\\"{ch['name']} → {ch['id']}\\\")\n\"\n```\n\nReplace `CHANNEL_NAMES_HERE` with the comma-separated names the user provided.\n\n**If `conversations.list` returns `missing_scope` or `not_authed`:**\nInform the user: *\"The token doesn't have permission to list channels. Please\nprovide the channel IDs directly (right-click a channel in Slack → Copy link  - \nthe last path segment starting with `C` is the ID).\"*\n\n**If the bot token lacks `channels:read`** for private channels, the user can\neither invite the bot first (`/invite @botname`) or switch to a user token.\n\nCollect up to 10 channel IDs. Record them as a Python list literal, e.g.:\n```python\n[\"C0123456789\", \"C9876543210\"]\n```\n\n### Step 2  -  Collect trigger phrase\n\nAsk the user: *\"What trigger phrase should OpenHands respond to?\n(Press Enter to use the default: `@openhands`)\"*\n\nAccepted values: any non-empty string unlikely to appear accidentally, e.g.\n`@openhands`, `jazz hands`, `take-me-to-funky-town`.\n\n### Step 3  -  Generate the automation script\n\nRead `scripts/main.py` from this skill's directory and **copy it verbatim**.\nApply exactly three constant substitutions near the top of the file:\n\n> **Do not reimplement, simplify, or hand-write a replacement script.**\n> The template already contains the correct secret-loading, state-path,\n> conversation-creation, and context-forwarding logic. Only the three\n> configuration constants below should change unless syntax validation fails.\n\n| Placeholder | Replace with |\n|---|---|\n| `TRIGGER_PHRASE = \"@openhands\"` | `TRIGGER_PHRASE = \"{user_phrase}\"` |\n| `CHANNEL_IDS: list[str] = []` | `CHANNEL_IDS: list[str] = {channel_id_list}` |\n| `DEFAULT_OPENHANDS_URL = \"http://localhost:8000\"` | `DEFAULT_OPENHANDS_URL = \"{url}\"` (keep default if user has no preference) |\n\nWrite the customised script to a temporary directory:\n```bash\nmkdir -p /tmp/slack-monitor-build\n# copy scripts/main.py to /tmp/slack-monitor-build/main.py\n# then replace only the three constants above\n```\n\nValidate syntax before packaging:\n```bash\npython3 -m py_compile /tmp/slack-monitor-build/main.py && echo \"Syntax OK\"\n```\n\nThen run a quick integrity check to confirm the template structure is still\npresent and only the configuration block was customised:\n```bash\ngrep -n 'TRIGGER_PHRASE = \"' /tmp/slack-monitor-build/main.py\ngrep -n 'CHANNEL_IDS: list\\[str\\] =' /tmp/slack-monitor-build/main.py\ngrep -n 'DEFAULT_OPENHANDS_URL = \"' /tmp/slack-monitor-build/main.py\ngrep -n 'def get_secret' /tmp/slack-monitor-build/main.py\ngrep -n 'def _state_file_path' /tmp/slack-monitor-build/main.py\ngrep -n 'def create_conversation' /tmp/slack-monitor-build/main.py\n```\n\nIf any of those checks fail, stop and re-copy the template instead of trying to\nrepair a hand-written variant.\n\n### Step 4  -  Package and upload\n\nDetermine the Automation backend URL and auth from the `<RUNTIME_SERVICES>`\nblock in your system context:\n- Use the **Automation backend** `url_from_agent` as `OPENHANDS_HOST`\n- Auth: `X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY`\n\nIf no Automation backend is listed in `<RUNTIME_SERVICES>`, stop and tell\nthe user to start the full automation stack.\n\n```bash\ntar -czf /tmp/slack-monitor.tar.gz -C /tmp/slack-monitor-build .\n\n# OPENHANDS_HOST: read from <RUNTIME_SERVICES> Automation backend url_from_agent\nOPENHANDS_HOST=\"<automation-url-from-runtime-services>\"\n\nTARBALL_PATH=$(curl -s -X POST \\\n  \"${OPENHANDS_HOST}/api/automation/v1/uploads?name=slack-channel-monitor\" \\\n  -H \"X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY\" \\\n  -H \"Content-Type: application/gzip\" \\\n  --data-binary @/tmp/slack-monitor.tar.gz \\\n  | python3 -c \"import json,sys; print(json.load(sys.stdin)['tarball_path'])\")\n\necho \"Uploaded: $TARBALL_PATH\"\n```\n\nIf the upload fails with a size error, the tarball must be under 1 MB.\n`main.py` is under 15 KB so this should never trigger.\n\n### Step 5  -  Create the automation\n\n```bash\ncurl -s -X POST \"${OPENHANDS_HOST}/api/automation/v1\" \\\n  -H \"X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \"{\n    \\\"name\\\": \\\"Slack Channel Monitor\\\",\n    \\\"trigger\\\": {\\\"type\\\": \\\"cron\\\", \\\"schedule\\\": \\\"* * * * *\\\"},\n    \\\"tarball_path\\\": \\\"$TARBALL_PATH\\\",\n    \\\"entrypoint\\\": \\\"python3 main.py\\\",\n    \\\"timeout\\\": 55\n  }\" | python3 -m json.tool\n```\n\nA 55-second timeout keeps runs well within the 60-second cron window.\n\nRecord the returned `id`  -  share it with the user as confirmation.\n\n### Step 6  -  Confirm\n\nTell the user:\n\n> ✅ **Slack Channel Monitor** is running!\n>\n> - Automation ID: `{id}`\n> - Channels: `{channel list}`\n> - Trigger phrase: `{phrase}`\n> - Polling every minute via cron `* * * * *`\n> - State file: `~/.openhands/workspaces/automation-state/slack_poller_{id}.json`\n>\n> Send a message containing `{phrase}` in any monitored channel to test it.\n> The bot will react with 👀 and reply with a link to the new conversation.\n\n---\n\n## Runtime Behaviour (per poll)\n\nEach cron run executes `main.py`, which runs **10 polling iterations** (every\n5 seconds) within the 55-second timeout window. Each iteration:\n\n1. **Loads state** from the JSON file (see `references/state-schema.md`).\n2. **Resolves the Slack token**  -  checks `SLACK_USER_TOKEN` then `SLACK_BOT_TOKEN`.\n3. **Fetches new messages:**\n   - User token + `search:read` + > 1 channel → single `search.messages` call\n     (searches for the trigger phrase across all channels).\n   - Otherwise → one `conversations.history` call per channel.\n4. **Fetches thread replies**  -  one `conversations.replies` call per tracked thread.\n5. **Processes messages** in chronological order:\n   - Skips messages already in `processed_ts` (dedup across the overlap window).\n   - Skips bot messages and any `ts` in `bot_message_ts`.\n   - Reply in a tracked thread (active **or** closed) → forwards to the existing\n     conversation; re-opens closed conversations automatically.\n   - Contains trigger phrase → 👀 reaction, create conversation, post link.\n     - Thread replies: agent receives full thread history for context.\n     - Root messages: agent receives the trigger text only.\n6. **Checks conversation statuses**  -  for each active conversation where\n   `time.time() - last_activity > 15 s`:\n   - If status is `idle`, `finished`, `error`, or `stuck` → fetch the agent's\n     final response via `/api/conversations/{id}/agent_final_response` and post\n     it to the Slack thread. Mark conversation `closed`.\n7. **Advances `last_poll`** to `now - 10 s` (overlap window prevents boundary\n   races). If a conversation creation failed, pins `last_poll` further back to\n   retry on the next iteration.\n8. **Saves state** (including `processed_ts`) and continues to the next iteration.\n9. After all iterations, fires the completion callback.\n\nDebug output is written to both stdout and a persistent log at:\n```\n{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log\n```\n\n---\n\n## Additional Resources\n\n### Reference Files\n\n- **`references/slack-api.md`**  -  Slack token types, required scopes, API\n  endpoint reference, rate limits, and common error codes.\n- **`references/state-schema.md`**  -  State JSON schema, field definitions,\n  example file, and conversation lifecycle diagram.\n\n### Script Template\n\n- **`scripts/main.py`**  -  The complete automation script. Customise the three\n  constants at the top (`TRIGGER_PHRASE`, `CHANNEL_IDS`, `DEFAULT_OPENHANDS_URL`)\n  before packaging.\n\n---\n\n## Troubleshooting\n\n| Symptom | Likely cause | Fix |\n|---|---|---|\n| Bot doesn't react to messages | Token missing or bot not in channel | Verify token with `auth.test`; `/invite @botname` |\n| `not_in_channel` error in run logs | Bot token used but bot not a member | Invite bot or switch to user token |\n| `missing_scope` error | Token lacks required scopes | Re-install Slack app with correct scopes (see `references/slack-api.md`) |\n| No messages detected | `last_poll` timestamp is in the future | Delete the state file to reset; it will be recreated on next run |\n| Conversation link 404 | `OPENHANDS_URL` points to wrong host | Set the `OPENHANDS_URL` secret to the correct base URL |\n| Summary never posted | Conversation stuck in `running` state | Check conversation in the OpenHands UI; the agent may need intervention |\n| Duplicate conversations created | `processed_ts` state missing or corrupted | Delete the state file to reset; dedup will rebuild on next run |\n| Trigger message processed on each cron run | State file deleted between runs | Ensure `automation-state/` directory is persistent across runs |\n| Debug info needed | Need detailed per-message trace | Check `{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log` |"
+    "content": "# Slack Channel Monitor\n\nCreate a cron automation that polls up to 10 Slack channels every minute.\nWhen a message containing the **trigger phrase** (default: `@openhands`) is\ndetected it:\n\n1. Adds a 👀 reaction to the triggering message.\n2. Opens an OpenHands conversation with the message and recent channel context.\n3. Posts a reply in the Slack thread with a link to the conversation.\n\nOn every subsequent run:\n- New Slack thread replies are forwarded only when they contain the trigger\n  phrase, so unrelated conversation in the thread is ignored.\n- When the conversation finishes (or errors), the agent's final response is\n  posted back to the Slack thread.\n- Completed conversations stay in a short follow-up watch window, allowing\n  triggered Slack replies to continue the same OpenHands conversation.\n\n> **Local mode only.** This automation targets the local OpenHands setup\n> (`dev:automation` stack). A cloud/webhook-based variant is out of scope here.\n\n---\n\n## Prerequisites\n\n### Required secrets\n\nVerify that at least one of the following secrets is set in\n**OpenHands Settings → Secrets** before proceeding:\n\n| Secret name | Token type | Minimum scopes |\n|---|---|---|\n| `SLACK_BOT_TOKEN` | Bot (`xoxb-…`) | `channels:history`, `channels:read`, `reactions:write`, `chat:write` |\n| `SLACK_USER_TOKEN` | User (`xoxp-…`) | Same as bot, plus `search:read` for multi-channel efficiency |\n\nCheck with:\n```bash\n# For bot token:\ncurl -s https://slack.com/api/auth.test -H \"Authorization: Bearer $SLACK_BOT_TOKEN\" \\\n  | python3 -c \"import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))\"\n\n# For user token:\ncurl -s https://slack.com/api/auth.test -H \"Authorization: Bearer $SLACK_USER_TOKEN\" \\\n  | python3 -c \"import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))\"\n```\n\nIf neither token is present, inform the user and stop  -  the automation cannot\nfunction without Slack credentials.\n\n### Optional secret\n\n| Secret name | Default | Purpose |\n|---|---|---|\n| `OPENHANDS_URL` | `http://localhost:8000` | Base URL used to build conversation links posted in Slack |\n\n---\n\n## Setup Workflow\n\nFollow these steps in order.\n\n### Step 1  -  Collect channels\n\nAsk the user: *\"Which Slack channels should be monitored? You can provide\nchannel names (e.g. `#general`) or IDs (e.g. `C0123456789`).\"*\n\n**If the user provides channel names**, resolve them to IDs:\n\n```bash\nSLACK_TOKEN=\"${SLACK_BOT_TOKEN:-$SLACK_USER_TOKEN}\"\ncurl -s \"https://slack.com/api/conversations.list?types=public_channel,private_channel&limit=200&exclude_archived=true\" \\\n  -H \"Authorization: Bearer $SLACK_TOKEN\" \\\n  | python3 -c \"\nimport json, sys\ndata = json.load(sys.stdin)\nif not data.get('ok'):\n    print('ERROR:', data.get('error'))\n    exit(1)\nnames = set(n.lstrip('#') for n in ['CHANNEL_NAMES_HERE'.split(',')])\nfor ch in data.get('channels', []):\n    if ch['name'] in names:\n        print(f\\\"{ch['name']} → {ch['id']}\\\")\n\"\n```\n\nReplace `CHANNEL_NAMES_HERE` with the comma-separated names the user provided.\n\n**If `conversations.list` returns `missing_scope` or `not_authed`:**\nInform the user: *\"The token doesn't have permission to list channels. Please\nprovide the channel IDs directly (right-click a channel in Slack → Copy link  - \nthe last path segment starting with `C` is the ID).\"*\n\n**If the bot token lacks `channels:read`** for private channels, the user can\neither invite the bot first (`/invite @botname`) or switch to a user token.\n\nCollect up to 10 channel IDs. Record them as a Python list literal, e.g.:\n```python\n[\"C0123456789\", \"C9876543210\"]\n```\n\n### Step 2  -  Collect trigger phrase\n\nAsk the user: *\"What trigger phrase should OpenHands respond to?\n(Press Enter to use the default: `@openhands`)\"*\n\nAccepted values: any non-empty string unlikely to appear accidentally, e.g.\n`@openhands`, `jazz hands`, `take-me-to-funky-town`.\n\n### Step 3  -  Generate the automation script\n\nRead `scripts/main.py` from this skill's directory and **copy it verbatim**.\nApply exactly three constant substitutions near the top of the file:\n\n> **Do not reimplement, simplify, or hand-write a replacement script.**\n> The template already contains the correct secret-loading, state-path,\n> conversation-creation, and context-forwarding logic. Only the three\n> configuration constants below should change unless syntax validation fails.\n\n| Placeholder | Replace with |\n|---|---|\n| `TRIGGER_PHRASE = \"@openhands\"` | `TRIGGER_PHRASE = \"{user_phrase}\"` |\n| `CHANNEL_IDS: list[str] = []` | `CHANNEL_IDS: list[str] = {channel_id_list}` |\n| `DEFAULT_OPENHANDS_URL = \"http://localhost:8000\"` | `DEFAULT_OPENHANDS_URL = \"{url}\"` (keep default if user has no preference) |\n\nWrite the customised script to a temporary directory:\n```bash\nmkdir -p /tmp/slack-monitor-build\n# copy scripts/main.py to /tmp/slack-monitor-build/main.py\n# then replace only the three constants above\n```\n\nValidate syntax before packaging:\n```bash\npython3 -m py_compile /tmp/slack-monitor-build/main.py && echo \"Syntax OK\"\n```\n\nThen run a quick integrity check to confirm the template structure is still\npresent and only the configuration block was customised:\n```bash\ngrep -n 'TRIGGER_PHRASE = \"' /tmp/slack-monitor-build/main.py\ngrep -n 'CHANNEL_IDS: list\\[str\\] =' /tmp/slack-monitor-build/main.py\ngrep -n 'DEFAULT_OPENHANDS_URL = \"' /tmp/slack-monitor-build/main.py\ngrep -n 'def get_secret' /tmp/slack-monitor-build/main.py\ngrep -n 'def _state_file_path' /tmp/slack-monitor-build/main.py\ngrep -n 'def create_conversation' /tmp/slack-monitor-build/main.py\n```\n\nIf any of those checks fail, stop and re-copy the template instead of trying to\nrepair a hand-written variant.\n\n### Step 4  -  Package and upload\n\nDetermine the Automation backend URL and auth from the `<RUNTIME_SERVICES>`\nblock in your system context:\n- Use the **Automation backend** `url_from_agent` as `OPENHANDS_HOST`\n- Auth: `X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY`\n\nIf no Automation backend is listed in `<RUNTIME_SERVICES>`, stop and tell\nthe user to start the full automation stack.\n\n```bash\ntar -czf /tmp/slack-monitor.tar.gz -C /tmp/slack-monitor-build .\n\n# OPENHANDS_HOST: read from <RUNTIME_SERVICES> Automation backend url_from_agent\nOPENHANDS_HOST=\"<automation-url-from-runtime-services>\"\n\nTARBALL_PATH=$(curl -s -X POST \\\n  \"${OPENHANDS_HOST}/api/automation/v1/uploads?name=slack-channel-monitor\" \\\n  -H \"X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY\" \\\n  -H \"Content-Type: application/gzip\" \\\n  --data-binary @/tmp/slack-monitor.tar.gz \\\n  | python3 -c \"import json,sys; print(json.load(sys.stdin)['tarball_path'])\")\n\necho \"Uploaded: $TARBALL_PATH\"\n```\n\nIf the upload fails with a size error, the tarball must be under 1 MB.\n`main.py` is under 15 KB so this should never trigger.\n\n### Step 5  -  Create the automation\n\n```bash\ncurl -s -X POST \"${OPENHANDS_HOST}/api/automation/v1\" \\\n  -H \"X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \"{\n    \\\"name\\\": \\\"Slack Channel Monitor\\\",\n    \\\"trigger\\\": {\\\"type\\\": \\\"cron\\\", \\\"schedule\\\": \\\"* * * * *\\\"},\n    \\\"tarball_path\\\": \\\"$TARBALL_PATH\\\",\n    \\\"entrypoint\\\": \\\"python3 main.py\\\",\n    \\\"timeout\\\": 55\n  }\" | python3 -m json.tool\n```\n\nA 55-second timeout keeps runs well within the 60-second cron window.\n\nRecord the returned `id`  -  share it with the user as confirmation.\n\n### Step 6  -  Confirm\n\nTell the user:\n\n> ✅ **Slack Channel Monitor** is running!\n>\n> - Automation ID: `{id}`\n> - Channels: `{channel list}`\n> - Trigger phrase: `{phrase}`\n> - Polling every minute via cron `* * * * *`\n> - State file: `~/.openhands/workspaces/automation-state/slack_poller_{id}.json`\n>\n> Send a message containing `{phrase}` in any monitored channel to test it.\n> The bot will react with 👀 and reply with a link to the new conversation.\n\n---\n\n## Runtime Behaviour (per poll)\n\nEach cron run executes `main.py`, which runs **10 polling iterations** (every\n5 seconds) within the 55-second timeout window. Each iteration:\n\n1. **Loads state** from the JSON file (see `references/state-schema.md`).\n2. **Resolves the Slack token**  -  checks `SLACK_USER_TOKEN` then `SLACK_BOT_TOKEN`.\n3. **Fetches new messages:**\n   - User token + `search:read` + > 1 channel → single `search.messages` call\n     (searches for the trigger phrase across all channels).\n   - Otherwise → one `conversations.history` call per channel.\n4. **Fetches due thread replies**  -  polls at most one tracked thread per\n   iteration using per-thread exponential backoff to stay within Slack rate\n   limits.\n5. **Processes messages** in chronological order:\n   - Skips messages already in `processed_ts` (dedup across the overlap window).\n   - Skips bot messages and any `ts` in `bot_message_ts`.\n   - Reply in a tracked thread whose text contains the trigger phrase → forwards\n     a follow-up request to the existing conversation and resets the follow-up\n     watch window. Replies without the trigger phrase are marked processed and\n     ignored.\n   - Contains trigger phrase outside a tracked conversation → 👀 reaction, create\n     a new conversation, post link.\n     - Thread replies: agent receives full thread history for context.\n     - Root messages: agent receives the trigger text only.\n6. **Checks conversation statuses**  -  for each active conversation where\n   `time.time() - last_activity > 15 s`:\n   - If status is `idle`, `finished`, `error`, or `stuck` → fetch the agent's\n     final response via `/api/conversations/{id}/agent_final_response` and post\n     it to the Slack thread. Mark the record `watching` for five minutes so\n     triggered follow-up replies can continue the same conversation.\n7. **Advances `last_poll`** to `now - 10 s` (overlap window prevents boundary\n   races). If a conversation creation failed, pins `last_poll` further back to\n   retry on the next iteration.\n8. **Saves state** (including `processed_ts`) and continues to the next iteration.\n9. After all iterations, fires the completion callback.\n\nDebug output is written to both stdout and a persistent log at:\n```\n{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log\n```\n\n---\n\n## Additional Resources\n\n### Reference Files\n\n- **`references/slack-api.md`**  -  Slack token types, required scopes, API\n  endpoint reference, rate limits, and common error codes.\n- **`references/state-schema.md`**  -  State JSON schema, field definitions,\n  example file, and conversation lifecycle diagram.\n\n### Script Template\n\n- **`scripts/main.py`**  -  The complete automation script. Customise the three\n  constants at the top (`TRIGGER_PHRASE`, `CHANNEL_IDS`, `DEFAULT_OPENHANDS_URL`)\n  before packaging.\n\n---\n\n## Troubleshooting\n\n| Symptom | Likely cause | Fix |\n|---|---|---|\n| Bot doesn't react to messages | Token missing or bot not in channel | Verify token with `auth.test`; `/invite @botname` |\n| `not_in_channel` error in run logs | Bot token used but bot not a member | Invite bot or switch to user token |\n| `missing_scope` error | Token lacks required scopes | Re-install Slack app with correct scopes (see `references/slack-api.md`) |\n| No messages detected | `last_poll` timestamp is in the future | Delete the state file to reset; it will be recreated on next run |\n| Conversation link 404 | `OPENHANDS_URL` points to wrong host | Set the `OPENHANDS_URL` secret to the correct base URL |\n| Summary never posted | Conversation stuck in `running` state | Check conversation in the OpenHands UI; the agent may need intervention |\n| Duplicate conversations created | `processed_ts` state missing or corrupted | Delete the state file to reset; dedup will rebuild on next run |\n| Trigger message processed on each cron run | State file deleted between runs | Ensure `automation-state/` directory is persistent across runs |\n| Debug info needed | Need detailed per-message trace | Check `{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log` |"
   },
   {
     "name": "slack-standup-digest",

package/skills/slack-channel-monitor/README.md

@@ -27,8 +27,10 @@ This skill is activated by keywords:
 - **Efficient polling**: single `search.messages` call for multi-channel user
   tokens with `search:read`; falls back to one `conversations.history` call
   per channel for bot tokens
-- **Thread tracking**: new replies in a triggered thread are forwarded to the
-  running OpenHands conversation
+- **Triggered follow-ups**: Slack thread replies that repeat the trigger phrase
+  are forwarded to the existing OpenHands conversation
+- **Watch window**: completed conversations keep watching their Slack thread for
+  short follow-up periods, with quiet threads backed off automatically
 - **Reaction acknowledgement**: adds a 👀 to every message containing the
   trigger phrase
 - **Conversation link**: posts a link to the new conversation in the Slack
@@ -79,9 +81,11 @@ Each cron run (every minute):
 3. Creates an OpenHands conversation with the message and recent channel
    context as the initial prompt; posts a link to the conversation in the
    Slack thread
-4. Forwards new replies in tracked threads to the running conversation
+4. Forwards triggered replies in tracked threads to the existing conversation,
+   while ignoring replies that do not contain the trigger phrase
 5. Checks active conversations - posts the agent's final response back to
-   Slack when the conversation completes
+   Slack when the conversation completes, then watches briefly for triggered
+   follow-up replies
 
 ## See Also
 

package/skills/slack-channel-monitor/SKILL.md

@@ -23,9 +23,12 @@ detected it:
 3. Posts a reply in the Slack thread with a link to the conversation.
 
 On every subsequent run:
-- Replies in the thread are forwarded to the running conversation.
+- New Slack thread replies are forwarded only when they contain the trigger
+  phrase, so unrelated conversation in the thread is ignored.
 - When the conversation finishes (or errors), the agent's final response is
   posted back to the Slack thread.
+- Completed conversations stay in a short follow-up watch window, allowing
+  triggered Slack replies to continue the same OpenHands conversation.
 
 > **Local mode only.** This automation targets the local OpenHands setup
 > (`dev:automation` stack). A cloud/webhook-based variant is out of scope here.
@@ -235,20 +238,26 @@ Each cron run executes `main.py`, which runs **10 polling iterations** (every
    - User token + `search:read` + > 1 channel → single `search.messages` call
      (searches for the trigger phrase across all channels).
    - Otherwise → one `conversations.history` call per channel.
-4. **Fetches thread replies**  -  one `conversations.replies` call per tracked thread.
+4. **Fetches due thread replies**  -  polls at most one tracked thread per
+   iteration using per-thread exponential backoff to stay within Slack rate
+   limits.
 5. **Processes messages** in chronological order:
    - Skips messages already in `processed_ts` (dedup across the overlap window).
    - Skips bot messages and any `ts` in `bot_message_ts`.
-   - Reply in a tracked thread (active **or** closed) → forwards to the existing
-     conversation; re-opens closed conversations automatically.
-   - Contains trigger phrase → 👀 reaction, create conversation, post link.
+   - Reply in a tracked thread whose text contains the trigger phrase → forwards
+     a follow-up request to the existing conversation and resets the follow-up
+     watch window. Replies without the trigger phrase are marked processed and
+     ignored.
+   - Contains trigger phrase outside a tracked conversation → 👀 reaction, create
+     a new conversation, post link.
      - Thread replies: agent receives full thread history for context.
      - Root messages: agent receives the trigger text only.
 6. **Checks conversation statuses**  -  for each active conversation where
    `time.time() - last_activity > 15 s`:
    - If status is `idle`, `finished`, `error`, or `stuck` → fetch the agent's
      final response via `/api/conversations/{id}/agent_final_response` and post
-     it to the Slack thread. Mark conversation `closed`.
+     it to the Slack thread. Mark the record `watching` for five minutes so
+     triggered follow-up replies can continue the same conversation.
 7. **Advances `last_poll`** to `now - 10 s` (overlap window prevents boundary
    races). If a conversation creation failed, pins `last_poll` further back to
    retry on the next iteration.

package/skills/slack-channel-monitor/references/slack-api.md

@@ -198,10 +198,12 @@ With < 10 channels polled every minute:
 | Method | Tier | Calls/min | Headroom |
 |--------|------|-----------|---------|
 | `conversations.history` | Tier 3 | ≤ 10 | Comfortable |
-| `conversations.replies` | Tier 3 | ≤ active threads | Fine unless hundreds of threads |
+| `conversations.replies` | Tier 3 | ≤ 1 due tracked thread per iteration | Throttled with per-thread backoff |
 | `search.messages` | Tier 2 | 1 | Fine |
 | `reactions.add` | Tier 2 | ≤ triggers/min | Fine |
 | `chat.postMessage` | Tier 3 | ≤ triggers + summaries | Fine |
 
-No rate-limit handling is implemented in the script. If you hit limits the
-run will fail and retry on the next cron tick.
+The script surfaces Slack HTTP 429 responses with `Retry-After`. Thread reply
+polling catches that signal, delays the affected thread, and increases its
+per-thread backoff. Other Slack methods still fail fast so the next cron tick can
+retry with the persisted state.

package/skills/slack-channel-monitor/references/state-schema.md

@@ -52,7 +52,7 @@ variable (field `automation_id`).
 
 ## `conversations` Map
 
-Key: `"{channel_id}:{thread_root_ts}"`  -  uniquely identifies a Slack thread.
+Key: `"{channel_id}:{thread_root_ts}"` - uniquely identifies a Slack thread.
 
 Value: **ConversationRecord**
 
@@ -61,14 +61,25 @@ Value: **ConversationRecord**
   // Required fields
   "conversation_id": "550e8400-e29b-41d4-a716-446655440000",
                                       // OpenHands conversation UUID
-  "channel_id":      "C0123456789",  // Slack channel ID
+  "channel_id":      "C0123456789", // Slack channel ID
   "thread_ts":       "1716576000.000100",
                                       // Slack thread root timestamp
                                       // (= msg_ts for top-level trigger messages)
-  "status":          "active",        // "active" | "closed"
-  "last_activity":   1716576060.0,    // float Unix timestamp of the last time the
-                                      // script sent a message to this conversation
-                                      // (creation time, or time a reply was forwarded)
+  "status":          "active",      // "active" | "watching" | "closed"
+  "last_activity":   1716576060.0,   // float Unix timestamp of the last time the
+                                      // script created, resumed, or summarized the
+                                      // OpenHands conversation
+
+  // Follow-up polling fields
+  "last_seen_reply_ts": "1716576000.000100",
+                                      // newest Slack reply ts observed for this thread
+  "reply_poll_backoff_seconds": 5,   // current per-thread conversations.replies backoff
+  "next_reply_poll_at": 1716576065.0,// next Unix timestamp when replies may be polled
+  "watch_until": 1716576360.0,       // follow-up watch expiry for completed conversations
+
+  // Present after expiry
+  "closed_reason": "followup_watch_expired",
+  "closed_at": 1716576360.0
 }
 ```
 
@@ -76,13 +87,13 @@ Value: **ConversationRecord**
 
 | Value | Meaning |
 |-------|---------|
-| `active` | Conversation is running or awaiting more input; replies will be forwarded |
-| `closed` | Summary has been posted to Slack; no further processing |
+| `active` | Conversation is running or awaiting completion; triggered replies are forwarded to it |
+| `watching` | A summary has been posted and the thread remains open briefly for triggered follow-ups |
+| `closed` | The follow-up watch expired; future triggered replies create a new conversation |
 
-Closed conversations are retained in the map indefinitely (the map stays small
-since there are < 10 channels and the trigger rate is typically low). If the
-map grows unexpectedly, closed entries older than a configurable TTL can be
-pruned.
+`watching` records use `watch_until` to avoid keeping every completed thread hot
+forever. Quiet watched threads use exponential backoff for `conversations.replies`
+polling, and each automation iteration polls at most one due thread.
 
 ---
 
@@ -109,9 +120,9 @@ exactly `now`, messages near the boundary are re-fetched on the next iteration.
 re-fetched messages from being processed twice (e.g., triggering a duplicate
 conversation or forwarding the same reply multiple times).
 
-Entries are added when a message is either skipped (not human, already handled)
-or successfully processed (trigger detected and conversation created, or reply
-forwarded).
+Entries are added when a message is either skipped (not human, already handled,
+or an untriggered reply in a watched thread) or successfully processed (trigger
+detected and conversation created, or triggered reply forwarded).
 
 ---
 
@@ -119,25 +130,33 @@ forwarded).
 
 ```
 [trigger detected]
-        │
-        ▼
+        |
+        v
   status = "active"
   last_activity = now
-        │
-  (next run or later runs)
-        │
-  ┌─────┴──────────────────────────────────────────┐
-  │  User sends a reply in the thread               │
-  │  → send_to_conversation() called               │
-  │  → last_activity = now                         │
-  └─────────────────────────────────────────────────┘
-        │
+  follow-up poll fields initialized
+        |
+        | triggered Slack reply while active
+        | -> send_to_conversation()
+        | -> last_activity = now
+        | -> watch window/backoff reset
+        |
   (when time.time() - last_activity > DONE_DEBOUNCE
-   AND conversation_status ∈ {idle, finished, error, stuck})
-        │
-        ▼
+   AND conversation_status in {idle, finished, error, stuck})
+        |
+        v
   Post summary to Slack thread
+  status = "watching"
+  watch_until = now + THREAD_FOLLOWUP_WATCH_SECONDS
+        |
+        | triggered Slack reply before watch_until
+        | -> send_to_conversation()
+        | -> status = "active"
+        |
+        | no triggered reply before watch_until
+        v
   status = "closed"
+  closed_reason = "followup_watch_expired"
 ```
 
 ---
@@ -158,14 +177,22 @@ forwarded).
       "channel_id": "C0123456789",
       "thread_ts": "1716575900.000100",
       "status": "active",
-      "last_activity": 1716575902.3
+      "last_activity": 1716575902.3,
+      "last_seen_reply_ts": "1716575900.000100",
+      "reply_poll_backoff_seconds": 5,
+      "next_reply_poll_at": 1716575907.3,
+      "watch_until": 1716576202.3
     },
     "C9876543210:1716570000.000500": {
       "conversation_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
       "channel_id": "C9876543210",
       "thread_ts": "1716570000.000500",
-      "status": "closed",
-      "last_activity": 1716572100.0
+      "status": "watching",
+      "last_activity": 1716572100.0,
+      "last_seen_reply_ts": "1716572050.000100",
+      "reply_poll_backoff_seconds": 20,
+      "next_reply_poll_at": 1716572120.0,
+      "watch_until": 1716572400.0
     }
   },
   "bot_message_ts": [

package/skills/slack-channel-monitor/scripts/main.py

@@ -9,7 +9,8 @@ trigger phrase is detected it:
   3. Posts a reply in the Slack thread with a link to the conversation.
 
 On subsequent runs:
-  - New replies in a tracked thread are forwarded to the running conversation.
+  - New replies in a tracked thread are forwarded only when they contain the
+    trigger phrase.
   - When the conversation reaches a terminal/idle state the agent's final
     response (or an error notice) is posted back to the Slack thread.
 
@@ -85,6 +86,18 @@ CONTEXT_MESSAGE_LIMIT = 15
 # How far back (seconds) to look for context when creating a new conversation.
 CONTEXT_LOOKBACK_SECONDS = 3600  # 1 hour of recent messages for context
 
+# Keep completed conversations available for triggered follow-up replies for a
+# short inactivity window. Polling conversations.replies is intentionally throttled:
+# bot-token Slack apps may have a very small per-method quota, so each thread
+# carries its own exponential backoff and each automation run polls at most one
+# due thread. Start hot immediately after each bot reply, then back off
+# on quiet threads.
+THREAD_FOLLOWUP_WATCH_SECONDS = 300
+THREAD_REPLY_INITIAL_BACKOFF_SECONDS = 5
+THREAD_REPLY_MAX_BACKOFF_SECONDS = 300
+THREAD_REPLY_BACKOFF_MULTIPLIER = 2
+MAX_THREAD_REPLY_POLLS_PER_RUN = 1
+
 
 # ── Stdlib helpers ─────────────────────────────────────────────────────────────
 
@@ -108,6 +121,55 @@ def get_secret(name: str) -> str:
         return r.read().decode().strip()
 
 
+def _is_loopback_openhands_url(url: str) -> bool:
+    return url.startswith((
+        "http://localhost",
+        "https://localhost",
+        "http://127.0.0.1",
+        "https://127.0.0.1",
+    ))
+
+
+def _ngrok_public_openhands_url() -> str | None:
+    try:
+        with urllib.request.urlopen(
+            "http://127.0.0.1:4040/api/tunnels", timeout=2
+        ) as response:
+            tunnels = json.loads(response.read()).get("tunnels", [])
+    except Exception as exc:
+        print(f"Could not discover ngrok public URL: {exc}")
+        return None
+
+    for tunnel in tunnels:
+        public_url = str(tunnel.get("public_url", "")).rstrip("/")
+        addr = str(tunnel.get("config", {}).get("addr", ""))
+        if (
+            public_url.startswith("https://")
+            and ("localhost:8000" in addr or "127.0.0.1:8000" in addr)
+        ):
+            return public_url
+
+    for tunnel in tunnels:
+        public_url = str(tunnel.get("public_url", "")).rstrip("/")
+        if public_url.startswith("https://"):
+            return public_url
+
+    return None
+
+
+def resolve_openhands_url() -> str:
+    try:
+        configured = get_secret("OPENHANDS_URL").rstrip()
+    except Exception:
+        configured = ""
+
+    configured = (configured or DEFAULT_OPENHANDS_URL).rstrip("/")
+    if not _is_loopback_openhands_url(configured):
+        return configured
+
+    return _ngrok_public_openhands_url() or configured
+
+
 def fire_callback(
     status: str = "COMPLETED",
     error: str | None = None,
@@ -195,8 +257,14 @@ def _slack_call(
     }
     data = json.dumps(body).encode() if body is not None else None
     req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    with urllib.request.urlopen(req) as r:
-        result = json.loads(r.read())
+    try:
+        with urllib.request.urlopen(req) as r:
+            result = json.loads(r.read())
+    except urllib.error.HTTPError as exc:
+        if exc.code == 429:
+            retry_after = exc.headers.get("Retry-After", "60")
+            raise RuntimeError(f"Slack {endpoint}: rate_limited retry_after={retry_after}") from exc
+        raise
     if not result.get("ok"):
         raise RuntimeError(f"Slack {endpoint}: {result.get('error', 'unknown_error')}")
     return result
@@ -273,6 +341,36 @@ def thread_replies(token: str, channel: str, thread_ts: str, oldest: str) -> lis
     return [m for m in messages if m.get("ts") != thread_ts]
 
 
+def _trigger_index(text: str) -> int:
+    """Return the start index of an exact trigger phrase match, or -1."""
+    lowered = text.lower()
+    trigger = TRIGGER_PHRASE.lower()
+    start = 0
+    while True:
+        idx = lowered.find(trigger, start)
+        if idx < 0:
+            return -1
+        before = lowered[idx - 1] if idx > 0 else ""
+        after_idx = idx + len(trigger)
+        after = lowered[after_idx] if after_idx < len(lowered) else ""
+        before_ok = not before or not (before.isalnum() or before in "_-")
+        after_ok = not after or not (after.isalnum() or after in "_-")
+        if before_ok and after_ok:
+            return idx
+        start = idx + 1
+
+
+def _has_trigger(text: str) -> bool:
+    return _trigger_index(text) >= 0
+
+
+def _request_after_trigger(text: str) -> str:
+    idx = _trigger_index(text)
+    if idx < 0:
+        return text
+    return text[idx + len(TRIGGER_PHRASE):].strip(" :–—")
+
+
 def full_thread_history(
     token: str, channel: str, thread_ts: str,
     bot_user_id: str, bot_message_ts: list[str],
@@ -567,14 +665,99 @@ def _gather_channel_context(
     return context_lines
 
 
+def _expire_inactive_thread_watches(active_convs: dict[str, dict], now: float) -> None:
+    for conv_key, rec in active_convs.items():
+        if rec.get("status") != "watching":
+            continue
+        watch_until = float(rec.get("watch_until") or 0)
+        if watch_until and now >= watch_until:
+            rec["status"] = "closed"
+            rec["closed_reason"] = "followup_watch_expired"
+            rec["closed_at"] = now
+            print(f"  Follow-up watch expired for {conv_key}")
+
+
+def _poll_due_thread_replies(
+    slack_token: str,
+    active_convs: dict[str, dict],
+    bot_user_id: str,
+    bot_message_ts: list[str],
+) -> list[tuple[str, dict]]:
+    now = time.time()
+    _expire_inactive_thread_watches(active_convs, now)
+    due: list[tuple[float, str, dict]] = []
+    for conv_key, rec in active_convs.items():
+        if rec.get("status") not in {"active", "watching"}:
+            continue
+        next_poll = float(rec.get("next_reply_poll_at") or 0)
+        if next_poll <= now:
+            due.append((next_poll, conv_key, rec))
+
+    reply_messages: list[tuple[str, dict]] = []
+    for _next_poll, conv_key, rec in sorted(due)[:MAX_THREAD_REPLY_POLLS_PER_RUN]:
+        cid = rec["channel_id"]
+        thread_ts = rec["thread_ts"]
+        oldest = rec.get("last_seen_reply_ts") or thread_ts
+        try:
+            replies = thread_replies(slack_token, cid, thread_ts, oldest)
+        except Exception as exc:
+            message = str(exc)
+            retry_after = THREAD_REPLY_MAX_BACKOFF_SECONDS
+            marker = "retry_after="
+            if marker in message:
+                raw = message.split(marker, 1)[1].split()[0]
+                try:
+                    retry_after = max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, int(raw))
+                except ValueError:
+                    pass
+            rec["next_reply_poll_at"] = now + retry_after
+            rec["reply_poll_backoff_seconds"] = min(
+                THREAD_REPLY_MAX_BACKOFF_SECONDS,
+                max(retry_after, int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)),
+            )
+            print(f"  Warning: could not fetch replies for thread {thread_ts}: {exc}")
+            continue
+
+        if replies:
+            rec["last_seen_reply_ts"] = max(r.get("ts", oldest) for r in replies)
+
+        human_replies = [r for r in replies if _is_human_message(r, bot_user_id, bot_message_ts)]
+        triggered_replies = [
+            r for r in human_replies
+            if _has_trigger(r.get("text", "") or "")
+        ]
+        if triggered_replies:
+            rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+            rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+            rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+            for r in triggered_replies:
+                reply_messages.append((cid, r))
+            print(f"  {conv_key}: {len(triggered_replies)} triggered follow-up reply/replies")
+        else:
+            if human_replies:
+                print(f"  {conv_key}: ignored {len(human_replies)} follow-up reply/replies without trigger")
+            current = int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)
+            next_backoff = min(
+                THREAD_REPLY_MAX_BACKOFF_SECONDS,
+                max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, current * THREAD_REPLY_BACKOFF_MULTIPLIER),
+            )
+            rec["reply_poll_backoff_seconds"] = next_backoff
+            rec["next_reply_poll_at"] = now + next_backoff
+            print(f"  {conv_key}: no follow-ups; next reply poll in {next_backoff}s")
+
+    return reply_messages
+
+
 def _poll_new_messages(
     slack_token: str,
     use_search: bool,
     oldest_by_channel: dict[str, str],
     global_oldest: str,
     active_convs: dict[str, dict],
+    bot_user_id: str,
+    bot_message_ts: list[str],
 ) -> list[tuple[str, dict]]:
-    """Collect and sort new top-level messages and thread replies from Slack."""
+    """Collect and sort new top-level messages and due thread replies from Slack."""
     new_messages: list[tuple[str, dict]] = []
 
     if use_search:
@@ -602,19 +785,9 @@ def _poll_new_messages(
             except Exception as exc:
                 print(f"  Warning: could not fetch history for {cid}: {exc}")
 
-    reply_messages: list[tuple[str, dict]] = []
-    for _conv_key, rec in active_convs.items():
-        if rec.get("status") == "closed":
-            continue
-        cid = rec["channel_id"]
-        thread_ts = rec["thread_ts"]
-        oldest = oldest_by_channel.get(cid, global_oldest)
-        try:
-            replies = thread_replies(slack_token, cid, thread_ts, oldest)
-            for r in replies:
-                reply_messages.append((cid, r))
-        except Exception as exc:
-            print(f"  Warning: could not fetch replies for thread {thread_ts}: {exc}")
+    reply_messages = _poll_due_thread_replies(
+        slack_token, active_convs, bot_user_id, bot_message_ts
+    )
 
     return sorted(
         new_messages + reply_messages,
@@ -669,10 +842,7 @@ def _process_trigger_message(
             print(f"  Warning: could not fetch thread history: {exc}")
 
     # Extract the user's request: the text that follows the trigger phrase.
-    request_part = text
-    idx = text.lower().find(TRIGGER_PHRASE.lower())
-    if idx >= 0:
-        request_part = text[idx + len(TRIGGER_PHRASE):].strip(" :–—")
+    request_part = _request_after_trigger(text)
 
     initial_prompt = (
         f"You are an AI assistant responding to a Slack message.\n\n"
@@ -697,12 +867,17 @@ def _process_trigger_message(
         conv_id = create_conversation(agent_url, api_key, initial_prompt)
         conv_url = f"{openhands_url}/conversations/{conv_id}"
 
+        now = time.time()
         active_convs[conv_key] = {
             "conversation_id": conv_id,
             "channel_id": channel_id,
             "thread_ts": thread_root,
             "status": "active",
-            "last_activity": time.time(),
+            "last_activity": now,
+            "last_seen_reply_ts": msg_ts,
+            "reply_poll_backoff_seconds": THREAD_REPLY_INITIAL_BACKOFF_SECONDS,
+            "next_reply_poll_at": now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS,
+            "watch_until": now + THREAD_FOLLOWUP_WATCH_SECONDS,
         }
 
         link_text = f"🤖 On it! View progress here: {conv_url}"
@@ -760,8 +935,16 @@ def _check_conversation_completion(
         if ts_back:
             bot_message_ts.append(ts_back)
 
-        rec["status"] = "closed"
-        print(f"  Posted summary for {conv_key}")
+        now = time.time()
+        rec["status"] = "watching"
+        rec["last_activity"] = now
+        rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+        rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+        rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+        print(
+            f"  Posted summary for {conv_key}; watching for follow-ups "
+            f"until {rec['watch_until']:.0f}"
+        )
 
 
 # ── Main ───────────────────────────────────────────────────────────────────────
@@ -776,10 +959,7 @@ def main() -> str | None:
 
     slack_token, token_is_user = _resolve_slack_token()
 
-    try:
-        openhands_url = get_secret("OPENHANDS_URL").rstrip("/") or DEFAULT_OPENHANDS_URL
-    except Exception:
-        openhands_url = DEFAULT_OPENHANDS_URL
+    openhands_url = resolve_openhands_url()
 
     # Raises RuntimeError immediately if the token is invalid - no point polling.
     bot_user_id_new, scopes = _slack_auth_test(slack_token)
@@ -808,7 +988,8 @@ def main() -> str | None:
     active_convs: dict[str, dict] = state.get("conversations", {})
 
     all_incoming = _poll_new_messages(
-        slack_token, use_search, oldest_by_channel, global_oldest, active_convs
+        slack_token, use_search, oldest_by_channel, global_oldest,
+        active_convs, bot_user_id, bot_message_ts,
     )
 
     print(f"  all_incoming: {len(all_incoming)} message(s), "
@@ -848,14 +1029,16 @@ def main() -> str | None:
         thread_root: str = thread_ts if thread_ts and thread_ts != msg_ts else msg_ts
         conv_key = f"{channel_id}:{thread_root}"
 
-        has_trigger = TRIGGER_PHRASE.lower() in text.lower()
+        has_trigger = _has_trigger(text)
         is_thread_reply = (
             thread_ts is not None
             and thread_ts != msg_ts
         )
+        tracked_rec = active_convs.get(conv_key)
         is_reply_in_tracked = (
             is_thread_reply
-            and conv_key in active_convs
+            and tracked_rec is not None
+            and tracked_rec.get("status") in {"active", "watching"}
         )
 
         print(f"  EVAL: ts={msg_ts} trigger={has_trigger} reply={is_thread_reply} "
@@ -863,20 +1046,39 @@ def main() -> str | None:
               f"text={text[:60]!r}")
 
         # ── Case A: reply in a thread that has a tracked conversation ──────────
-        # Route to the existing conversation regardless of its status (active or
-        # closed).  If the conversation was closed, re-activate it so the agent
-        # processes the new message and the completion check fires again later.
+        # Route to the existing conversation while it is active or in its
+        # follow-up watch window, but only when the reply includes the trigger
+        # phrase. Once the watch expires, a new trigger in the thread creates a
+        # fresh conversation instead.
         if is_reply_in_tracked:
             rec = active_convs[conv_key]
-            print(f"  → Case A: Forwarding reply {msg_ts} → conversation {rec['conversation_id']}")
+            rec["last_seen_reply_ts"] = max(rec.get("last_seen_reply_ts", msg_ts), msg_ts)
+            if not has_trigger:
+                processed_ts.add(msg_ts)
+                print(f"  → Case A ignored (tracked reply without trigger): {msg_ts}")
+                continue
+
+            request_part = _request_after_trigger(text)
+            print(f"  → Case A: Forwarding triggered reply {msg_ts} → conversation {rec['conversation_id']}")
             try:
-                send_to_conversation(agent_url, api_key, rec["conversation_id"],
-                                     f"User replied in Slack thread: {text}")
+                send_to_conversation(
+                    agent_url, api_key, rec["conversation_id"],
+                    (
+                        f"User <@{msg.get('user', '?')}> replied in Slack thread.\n"
+                        f"The reply was activated by the trigger phrase: `{TRIGGER_PHRASE}`\n"
+                        f"Full reply: {text}\n"
+                        f"User request: {request_part or '(no explicit request — use your best judgement)'}"
+                    ),
+                )
+                now = time.time()
                 rec["status"] = "active"
-                rec["last_activity"] = time.time()
+                rec["last_activity"] = now
+                rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+                rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+                rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
             except Exception as exc:
                 print(f"  Warning: failed to forward reply: {exc}")
-            if has_trigger and can_react:
+            if can_react:
                 add_reaction(slack_token, channel_id, msg_ts)
             processed_ts.add(msg_ts)
             continue
@@ -922,7 +1124,7 @@ def main() -> str | None:
     print(f"  last_poll set to {effective_last_poll}")
 
     for conv_key, rec in list(active_convs.items()):
-        if rec.get("status") != "closed":
+        if rec.get("status") == "active":
             _check_conversation_completion(
                 conv_key, rec, agent_url, api_key, slack_token, bot_message_ts,
             )