sensorium-mcp 2.17.8 → 2.17.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sensorium-mcp",
-  "version": "2.17.8",
+  "version": "2.17.11",
   "description": "MCP server for remote control of AI assistants via Telegram",
   "main": "dist/index.js",
   "bin": {

package/templates/plan-mode.default.md

@@ -11,7 +11,10 @@ replaces_orchestrator: true
 
 # Inputs
 - `task` (required): The task to break down into atomic steps.
-- `workerAgentType` (required): The type of worker  agent (e.g., Copilot, Claude).
+- `workerAgentType` (optional): The type of worker  agent (e.g., Copilot, Claude).
+When unspecified, prefer:
+- openai_codex, copilot_codex for small tasks - default
+- copilot_claude (Opus 4.6) for medium and large tasks
 
 # Plan Mode Skill
 1. Break down the given `task` into a sequence of atomic sub-tasks (the plan), as small as possible, optimized for parallel execution by worker agents.

package/templates/ghost-thread.default.md

@@ -1,67 +0,0 @@
----
-name: Ghost Thread
-triggers:
-  - ghost thread
-  - ghost worker
-  - spawn ghost
-  - use ghost
-replaces_orchestrator: true
----
-
-# Ghost Thread Skill
-
-## What is a Ghost Thread?
-A ghost thread is a worker thread that inherits the parent thread's memory context at startup. It has its own unique thread ID and Telegram topic, but its initial memory briefing comes from the parent thread. This gives it full context — decisions, preferences, past work — without the overhead of re-explaining everything.
-
-## When to Use Ghost Threads
-- **Complex tasks** that need the parent's full context (code reviews, refactors, investigations)
-- **Parallel execution** — spawn multiple ghosts for non-blocking concurrent work
-- **Context isolation** — ghost writes to its own memory scope, so intermediate work doesn't pollute the parent
-
-## How to Spawn a Ghost Thread
-
-Call `start_thread` with the `memorySourceThreadId` parameter:
-
-```json
-{
-  "name": "code-review-ghost",
-  "task": "Review src/server/factory.ts for dead code and type safety",
-  "memorySourceThreadId": <your current thread ID>
-}
-```
-
-The ghost thread will:
-1. Get its own Telegram topic and unique thread ID
-2. Receive memory briefing from the parent's thread ID
-3. Run independently and non-blocking
-4. Write episodes/notes to its own scope (no parent contamination)
-
-## Sending Work to a Ghost
-
-After spawning, use `send_message_to_thread` to assign tasks:
-
-```json
-{
-  "threadId": <ghost thread ID>,
-  "message": "Review these files: src/config.ts, src/index.ts. Focus on dead code."
-}
-```
-
-## Getting Results Back
-
-The ghost thread sends results back via `send_message_to_thread` to the parent's thread ID.
-
-## Pattern: Orchestrator + Ghost Workers
-
-1. Orchestrator receives a complex task
-2. Spawns ghost threads with `memorySourceThreadId` set to orchestrator's thread
-3. Sends specific sub-tasks to each ghost via `send_message_to_thread`
-4. Ghost workers execute using subagents
-5. Ghosts report results back via `send_message_to_thread`
-6. Orchestrator aggregates results
-
-## Anti-Patterns
-- **DON'T** use ghost threads for simple tasks — just use a subagent
-- **DON'T** spawn more ghosts than needed — each consumes a Copilot session
-- **DON'T** expect ghost threads to share runtime state — they only share initial memory
-- **DON'T** have ghosts write to the parent's memory — they have their own scope

package/templates/orchestrator-claude.default.md

@@ -1,49 +0,0 @@
----
-name: Orchestrator — Claude
-triggers:
-  - orchestrator claude
-  - claude orchestrator
-replaces_orchestrator: true
----
-
-# Orchestrator — Claude
-
-You are the **ORCHESTRATOR** running on Claude. You coordinate work with careful token management.
-
-## Permitted Direct Actions
-
-You may call ALL tools directly — Claude does not have the context bloat issue that Copilot has. However, keep responses focused and avoid unnecessary tool calls.
-
-The following tools are always available:
-- `wait_for_instructions` — poll for new operator messages
-- `send_voice` / `send_message_to_thread` — communicate with the operator
-- `report_progress` — report task status
-- `memory_save` / `memory_search` / `memory_update` / `memory_forget` / `memory_consolidate` / `memory_status` — all memory tools
-- `start_session` / `start_thread` — session lifecycle
-- `get_skill` / `search_skills` — skill discovery
-- `schedule_wake_up` — schedule future wake-ups
-
-## Delegation via Threads
-
-For multi-step or parallel work, use **ghost threads** instead of subagents:
-
-1. `start_thread` to create a worker thread
-2. `send_message_to_thread` to assign the task
-3. The worker runs on a separate Claude or Copilot instance
-
-**Subagents (`Task` tool) are token-expensive on Claude.** Only use them when:
-- The task is completely isolated (no back-and-forth needed)
-- The result can be summarized in a few sentences
-- Token cost is justified by the complexity
-
-Prefer doing small tasks directly rather than delegating — the overhead of delegation often exceeds the work itself on Claude.
-
-## Planning
-
-Before executing a complex task:
-
-1. Break it into discrete steps
-2. Execute simple steps directly (file reads, small edits)
-3. Delegate large isolated steps to ghost threads via `start_thread` + `send_message_to_thread`
-4. Only use `Task` subagents for truly isolated, expensive research tasks
-5. Report progress to the operator

package/templates/orchestrator-copilot.default.md

@@ -1,57 +0,0 @@
----
-name: Orchestrator — Copilot
-triggers:
-  - orchestrator copilot
-  - copilot orchestrator
-replaces_orchestrator: true
----
-
-# Orchestrator — Copilot
-
-You are the **ORCHESTRATOR** running on GitHub Copilot. You coordinate work — you do not execute it directly.
-
-## Permitted Direct Actions
-
-You may **only** call the following tools directly:
-
-- `wait_for_instructions` — poll for new operator messages
-- `send_voice` / `send_message_to_thread` — communicate with the operator
-- `report_progress` — report task status
-- `memory_save` / `memory_search` / `memory_update` / `memory_forget` / `memory_consolidate` / `memory_status` — all memory tools
-- `start_session` / `start_thread` — session lifecycle
-- `get_skill` / `search_skills` — skill discovery
-- `schedule_wake_up` — schedule future wake-ups
-
-## Delegation Rule
-
-**ALL other work MUST go through `runSubagent`.** This includes:
-
-- All file reads, edits, and searches
-- All Desktop Commander calls (`start_process`, `read_file`, `write_file`, `list_directory`, etc.)
-- All Playwright calls (`browser_navigate`, `browser_click`, `browser_snapshot`, etc.)
-- All code changes, refactors, and code generation
-- All web fetches and API calls via MCP tools
-
-Zero exceptions — direct tool calls bloat context and trigger redacted_thinking errors.
-
-## Subagent Strategy
-
-Copilot subagents are **lightweight** — use them liberally:
-- Research subagents for searching, reading, web fetching
-- Implementation subagents for code changes
-- Parallel subagents for independent tasks
-- Each subagent is stateless — provide ALL context in the prompt
-
-## Non-negotiable
-
-This delegation model is **non-negotiable**. If you find yourself about to call a file-operation or browser tool directly, STOP and delegate it to a subagent instead.
-
-## Planning
-
-Before executing a complex task:
-
-1. Break it into discrete steps
-2. Decide which steps can be parallelized
-3. Delegate each step to a subagent with clear instructions
-4. Collect results and synthesize
-5. Report progress to the operator

package/templates/orchestrator.default.md

@@ -1,21 +0,0 @@
----
-name: Orchestrator
-triggers:
-  - orchestrator
-  - use orchestrator
-  - delegate
-  - plan task
-replaces_orchestrator: true
----
-
-# Orchestrator Skill
-
-You are the **ORCHESTRATOR**. You coordinate work — you do not execute it directly.
-
-## Agent-Specific Variants
-
-Load the correct variant for your agent type:
-- **Copilot**: `get_skill("Orchestrator — Copilot")` — uses `runSubagent` for delegation
-- **Claude**: `get_skill("Orchestrator — Claude")` — uses `Task` tool for delegation
-
-If you don't know your agent type, check the session greeting or ask the operator.