feat(tasklist): per-task model/effort overrides + docker-compose + entrypoint

Task model support
------------------
- TaskItem gains optional `model` and `effort` fields (e.g. "opus", "high")
- DB migration 6: ALTER TABLE adds `model TEXT` and `effort TEXT` columns
- TaskListRepository.add_task() accepts model/effort and persists them
- /tasks add and /tasks plan parse --model and --effort flags anywhere in
  the argument string (case-insensitive, validated against known values)
- /tasks list shows a [Opus/high] badge next to tasks that have an override
- /tasks plan applies the flags as a batch default to every generated task

Runner model resolution (priority order)
-----------------------------------------
  1. Per-task model/effort stored in the DB
  2. Runner-wide default — inherited from the user's active /model setting
     at the time /taskrun was issued (context.user_data model_override /
     effort_override, set by PR RichardAtCT#160's /model command)
  3. API/CLI default (no override passed)

/taskrun confirmation message now names the active default model when set.
The sanity-check call uses the same model as the task itself.

Docker
------
- Add entrypoint.sh: generates an SSH keypair on first run and prints the
  public key, then execs claude-telegram-bot
- Add docker-compose.yml: builds from local source (pyproject.toml pip
  install), mounts Claude CLI binary from host, persists SQLite data and
  SSH key in named volumes across rebuilds

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: claude

docker-compose.yml

@@ -0,0 +1,67 @@
+# docker-compose.yml — claude-code-telegram-tasklist on Raspberry Pi
+# Builds directly from this repo — no external image pull needed.
+#
+# Setup on your Pi:
+#   1. Install & auth Claude CLI:  claude   (follow the prompts)
+#   2. Copy .env.template → .env and fill in your values
+#   3. docker compose up -d --build
+
+services:
+  claude-tg-bot:
+    build:
+      context: .
+      dockerfile_inline: |
+        FROM python:3.11-slim
+
+        RUN apt-get update && apt-get install -y --no-install-recommends \
+                git curl ca-certificates sqlite3 openssh-client \
+            && rm -rf /var/lib/apt/lists/*
+
+        WORKDIR /app
+
+        # Install the bot from the local source tree (pyproject.toml)
+        COPY pyproject.toml poetry.lock* ./
+        RUN pip install --no-cache-dir --upgrade pip \
+         && pip install --no-cache-dir .
+
+        # Copy the rest of the source (keeps the pip layer cached on dep-only changes)
+        COPY src ./src
+
+        # Claude auth credentials baked into the image at build time.
+        # Delete this COPY and uncomment the runtime volume below if you prefer
+        # to mount credentials without baking them into an image layer.
+        COPY .claude /root/.claude
+        RUN mkdir -p /root/.ssh /root/.claude
+
+        COPY entrypoint.sh /entrypoint.sh
+        RUN chmod +x /entrypoint.sh
+
+        ENTRYPOINT ["/entrypoint.sh"]
+
+    image: claude-tg-bot
+    restart: unless-stopped
+
+    environment:
+      - TZ=Europe/Warsaw      # adjust to your timezone
+
+    env_file:
+      - .env                  # copy .env.template → .env and fill in your values
+
+    volumes:
+      # Claude CLI binary from the host Pi.
+      # Run `which claude` on the Pi if it lives somewhere else.
+      - /home/k4rnaj1k/.local/bin/claude:/usr/local/bin/claude:ro
+
+      # Uncomment to mount Claude credentials at runtime instead of baking them in:
+      # - /home/k4rnaj1k/.claude:/root/.claude:ro
+
+      # Your projects directory — must match APPROVED_DIRECTORY in .env
+      - ./projects:/projects
+
+      # Persistent SQLite database and SSH key across container rebuilds
+      - claude_bot_data:/app/data
+      - claude_bot_ssh:/root/.ssh
+
+volumes:
+  claude_bot_data:
+  claude_bot_ssh:

entrypoint.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -e
+
+# Generate SSH key if it doesn't exist yet
+if [ ! -f /root/.ssh/id_ed25519 ]; then
+  ssh-keygen -t ed25519 -C "claude-tg-bot@container" -f /root/.ssh/id_ed25519 -N ""
+fi
+
+echo ""
+echo "════════════════════════════════════════════════════════"
+echo "  SSH PUBLIC KEY — add this to your GitHub/Gitea/etc:"
+echo "════════════════════════════════════════════════════════"
+cat /root/.ssh/id_ed25519.pub
+echo "════════════════════════════════════════════════════════"
+echo ""
+
+exec /usr/local/bin/claude-telegram-bot

src/bot/orchestrator.py

@@ -1786,21 +1786,50 @@ async def _agentic_callback(
     # Task list commands
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _parse_task_flags(text: str) -> tuple:
+        """Strip --model and --effort flags from *text*, return (model, effort, clean_text).
+
+        Accepted forms (case-insensitive, anywhere in the string):
+          --model opus        --model sonnet    --model haiku
+          --effort low        --effort medium   --effort high   --effort max
+        """
+        import re as _re
+
+        _VALID_MODELS = {"opus", "sonnet", "haiku"}
+        _VALID_EFFORTS = {"low", "medium", "high", "max"}
+
+        model: Optional[str] = None
+        effort: Optional[str] = None
+
+        def _extract(pattern: str, valid: set, src: str) -> tuple:
+            m = _re.search(pattern, src, _re.IGNORECASE)
+            if m:
+                val = m.group(1).lower()
+                if val in valid:
+                    return val, src[: m.start()].rstrip() + " " + src[m.end() :].lstrip()
+            return None, src
+
+        model, text = _extract(r"--model\s+(\S+)", _VALID_MODELS, text)
+        effort, text = _extract(r"--effort\s+(\S+)", _VALID_EFFORTS, text)
+        return model, effort, text.strip()
+
     async def agentic_tasks(
         self, update: Update, context: ContextTypes.DEFAULT_TYPE
     ) -> None:
         """Manage the task list.
 
         Usage:
-          /tasks                    — show list
-          /tasks add <description>  — add a task manually
-          /tasks plan <description> — ask Claude to decompose into tasks
-          /tasks del <id>           — delete a task by id
-          /tasks clear              — clear all tasks
-          /tasks reset              — reset failed/in-progress tasks to pending
+          /tasks                                        — show list
+          /tasks add [--model M] [--effort E] <desc>   — add a task
+          /tasks plan [--model M] [--effort E] <desc>  — Claude decomposes into tasks
+          /tasks del <id>                               — delete a task by id
+          /tasks clear                                  — clear all tasks
+          /tasks reset                                  — reset failed/in-progress to pending
+
+        Model values : opus · sonnet · haiku
+        Effort values: low · medium · high · max  (model-dependent)
         """
-        from ..tasklist.runner import TaskRunner  # local import, already cached
-
         user_id = update.effective_user.id
         storage = context.bot_data.get("storage")
         if not storage:
@@ -1814,7 +1843,7 @@ async def agentic_tasks(
         rest = parts[2].strip() if len(parts) > 2 else ""
 
         # --- show list ---
-        if sub == "" or sub == "list":
+        if sub in ("", "list"):
             tasks = await task_repo.get_tasks(user_id)
             if not tasks:
                 await update.message.reply_text(
@@ -1827,14 +1856,23 @@ async def agentic_tasks(
 
             counts = await task_repo.count_by_status(user_id)
             running = self._task_runners.get(user_id)
-            runner_badge = " · <b>runner active</b>" if (
-                running and running.is_running()
-            ) else ""
+            runner_badge = (
+                " · <b>runner active</b>"
+                if running and running.is_running()
+                else ""
+            )
 
             lines = [f"📋 <b>Task list</b>{runner_badge}\n"]
             for t in tasks:
                 desc = escape_html(t.description[:80])
-                lines.append(f"{t.icon} <code>{t.id}</code> {desc}")
+                model_badge = (
+                    f" <code>[{t.model.capitalize()}"
+                    + (f"/{t.effort}" if t.effort else "")
+                    + "]</code>"
+                    if t.model
+                    else ""
+                )
+                lines.append(f"{t.icon} <code>{t.id}</code>{model_badge} {desc}")
 
             summary_parts = []
             for status, label in (
@@ -1848,7 +1886,7 @@ async def agentic_tasks(
                     summary_parts.append(f"{n} {label}")
             lines.append("\n" + " · ".join(summary_parts))
             lines.append(
-                "\n<i>/taskrun to start · /tasks add &lt;desc&gt; to add more</i>"
+                "\n<i>/taskrun to start · /tasks add [--model opus] &lt;desc&gt;</i>"
             )
 
             await update.message.reply_text("\n".join(lines), parse_mode="HTML")
@@ -1858,13 +1896,26 @@ async def agentic_tasks(
         if sub == "add":
             if not rest:
                 await update.message.reply_text(
-                    "Usage: <code>/tasks add &lt;description&gt;</code>",
+                    "Usage: <code>/tasks add [--model opus|sonnet|haiku]"
+                    " [--effort low|medium|high|max] &lt;description&gt;</code>",
                     parse_mode="HTML",
                 )
                 return
-            task = await task_repo.add_task(user_id, rest)
+            model, effort, desc = self._parse_task_flags(rest)
+            if not desc:
+                await update.message.reply_text("Please include a task description.")
+                return
+            task = await task_repo.add_task(user_id, desc, model=model, effort=effort)
+            badge = (
+                f" <code>[{model.capitalize()}"
+                + (f"/{effort}" if effort else "")
+                + "]</code>"
+                if model
+                else ""
+            )
             await update.message.reply_text(
-                f"✅ Task <code>{task.id}</code> added: <i>{escape_html(rest[:80])}</i>",
+                f"✅ Task <code>{task.id}</code> added{badge}:"
+                f" <i>{escape_html(desc[:80])}</i>",
                 parse_mode="HTML",
             )
             return
@@ -1873,8 +1924,8 @@ async def agentic_tasks(
         if sub == "plan":
             if not rest:
                 await update.message.reply_text(
-                    "Usage: <code>/tasks plan &lt;description&gt;</code>\n"
-                    "Example: <code>/tasks plan refactor auth, add dark mode, write tests</code>",
+                    "Usage: <code>/tasks plan [--model M] [--effort E] &lt;description&gt;</code>\n"
+                    "Example: <code>/tasks plan --model opus refactor auth, add dark mode</code>",
                     parse_mode="HTML",
                 )
                 return
@@ -1884,14 +1935,20 @@ async def agentic_tasks(
                 await update.message.reply_text("Claude integration unavailable.")
                 return
 
+            # Flags here apply to every created task (acts as a batch default).
+            model, effort, description = self._parse_task_flags(rest)
+            if not description:
+                await update.message.reply_text("Please include a description to plan.")
+                return
+
             thinking_msg = await update.message.reply_text("🧠 Planning tasks…")
 
             decompose_prompt = (
                 "Break the following work description into a concise, ordered task list.\n"
                 "Output ONLY the tasks — one per line, no numbering, no bullet points, "
                 "no extra commentary.\n"
                 "Each line must be a single, self-contained actionable task.\n\n"
-                f"Work description: {rest}"
+                f"Work description: {description}"
             )
 
             current_dir = context.user_data.get(
@@ -1930,13 +1987,20 @@ async def agentic_tasks(
                 return
 
             created = []
-            for desc in task_lines:
-                t = await task_repo.add_task(user_id, desc)
+            for task_desc in task_lines:
+                t = await task_repo.add_task(
+                    user_id, task_desc, model=model, effort=effort
+                )
                 created.append(t)
 
-            lines = [
-                f"📋 <b>{len(created)} task(s) created:</b>\n"
-            ]
+            model_note = (
+                f" (all using <code>{model.capitalize()}"
+                + (f"/{effort}" if effort else "")
+                + "</code>)"
+                if model
+                else ""
+            )
+            lines = [f"📋 <b>{len(created)} task(s) created{model_note}:</b>\n"]
             for t in created:
                 lines.append(
                     f"{t.icon} <code>{t.id}</code> <i>{escape_html(t.description[:80])}</i>"
@@ -1967,15 +2031,12 @@ async def agentic_tasks(
         # --- clear ---
         if sub == "clear":
             count = await task_repo.clear_tasks(user_id)
-            await update.message.reply_text(
-                f"🗑️ Cleared {count} task(s)."
-            )
+            await update.message.reply_text(f"🗑️ Cleared {count} task(s).")
             return
 
         # --- reset ---
         if sub == "reset":
             count = await task_repo.reset_stale_in_progress(user_id)
-            # Also reset explicitly failed tasks to pending
             tasks = await task_repo.get_tasks(user_id)
             reset_failed = 0
             for t in tasks:
@@ -1994,13 +2055,16 @@ async def agentic_tasks(
         await update.message.reply_text(
             "<b>Task list commands:</b>\n"
             "<code>/tasks</code> — show list\n"
-            "<code>/tasks add &lt;description&gt;</code> — add a task\n"
-            "<code>/tasks plan &lt;description&gt;</code> — Claude plans tasks for you\n"
+            "<code>/tasks add [--model M] [--effort E] &lt;desc&gt;</code> — add a task\n"
+            "<code>/tasks plan [--model M] [--effort E] &lt;desc&gt;</code>"
+            " — Claude plans tasks for you\n"
             "<code>/tasks del &lt;id&gt;</code> — delete a task\n"
             "<code>/tasks clear</code> — clear all tasks\n"
             "<code>/tasks reset</code> — reset failed tasks to pending\n"
             "<code>/taskrun</code> — start the runner\n"
-            "<code>/taskstop</code> — stop the runner",
+            "<code>/taskstop</code> — stop the runner\n\n"
+            "<i>Model: opus · sonnet · haiku"
+            " | Effort: low · medium · high · max</i>",
             parse_mode="HTML",
         )
 
@@ -2041,6 +2105,11 @@ async def agentic_taskrun(
         )
         session_id = context.user_data.get("claude_session_id")
 
+        # Inherit the user's active /model selection as the runner-wide default.
+        # Individual tasks can still override this via their own model field.
+        default_model = context.user_data.get("model_override")
+        default_effort = context.user_data.get("effort_override")
+
         runner = TaskRunner(
             user_id=user_id,
             chat_id=update.effective_chat.id,
@@ -2049,12 +2118,23 @@ async def agentic_taskrun(
             claude_integration=claude_integration,
             working_directory=current_dir,
             session_id=session_id,
+            default_model=default_model,
+            default_effort=default_effort,
         )
         self._task_runners[user_id] = runner
         runner.start()
 
+        model_note = (
+            f" using <b>{default_model.capitalize()}"
+            + (f"/{default_effort}" if default_effort else "")
+            + "</b> as default"
+            if default_model
+            else ""
+        )
         await update.message.reply_text(
-            "▶️ Task runner started. I'll work through your list and report back.",
+            f"▶️ Task runner started{model_note}."
+            " I'll work through your list and report back.",
+            parse_mode="HTML",
         )
 
         audit_logger = context.bot_data.get("audit_logger")

src/storage/database.py

@@ -309,6 +309,14 @@ def _get_migrations(self) -> List[Tuple[int, str]]:
                     ON task_list_items(user_id, position);
                 """,
             ),
+            (
+                6,
+                """
+                -- Add per-task model and effort overrides
+                ALTER TABLE task_list_items ADD COLUMN model TEXT;
+                ALTER TABLE task_list_items ADD COLUMN effort TEXT;
+                """,
+            ),
             (
                 4,
                 """

src/tasklist/models.py

@@ -42,12 +42,24 @@ class TaskItem:
     created_at: Optional[datetime] = None
     completed_at: Optional[datetime] = None
     notes: Optional[str] = None  # last sanity-check result
+    model: Optional[str] = None   # e.g. "opus", "sonnet", "haiku"
+    effort: Optional[str] = None  # e.g. "low", "medium", "high", "max"
 
     @property
     def icon(self) -> str:
         """Status icon for display."""
         return STATUS_ICONS.get(self.status, "❓")
 
+    @property
+    def model_badge(self) -> str:
+        """Short display string for model+effort, empty if unset."""
+        if not self.model:
+            return ""
+        badge = self.model.capitalize()
+        if self.effort:
+            badge += f"/{self.effort}"
+        return f" [{badge}]"
+
     def to_dict(self) -> Dict[str, Any]:
         """Serialise for storage / logging."""
         data = asdict(self)