taskboy 0.1.1__py3-none-any.whl

taskboy/prompts.py

@@ -0,0 +1,288 @@
+"""plain-string prompt templates: the classifier call and the per-task sub-agent session."""
+
+import json
+from typing import Any
+
+from taskboy.models import Task
+
+CONVENTIONS_FILENAME = "CONVENTIONS.md"  # workspace filename the conventions doc is copied to (runner.py) and cited as (task prompt)
+
+CLASSIFICATION_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "task_type": {"type": "string", "enum": ["question", "investigation", "bug_fix", "feature", "pr_review", "incident_diagnosis", "jira_ops", "unsupported"]},
+        "complexity": {"type": "string", "enum": ["trivial", "standard", "complex", "critical"]},
+        "risk": {"type": "string", "enum": ["read_only", "writes_code", "writes_jira", "writes_code_and_jira"]},
+        "expected_duration": {"type": "string", "enum": ["minutes", "under_hour", "hours"]},
+        "required_integrations": {"type": "array", "items": {"type": "string", "enum": ["github", "aws", "sentry", "jira", "confluence"]}},
+        "target_repos": {"type": "array", "items": {"type": "string"}},
+        "jira_keys": {"type": "array", "items": {"type": "string"}},
+        "effort": {"type": "string", "enum": ["low", "medium", "high", "xhigh", "max", "auto"]},
+    },
+    "required": ["task_type", "complexity", "risk", "expected_duration", "required_integrations", "target_repos", "jira_keys"],
+    "additionalProperties": False,
+}
+
+QUICK_ANSWER_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {"action": {"type": "string", "enum": ["answer", "escalate"]}, "answer": {"type": "string"}},
+    "required": ["action", "answer"],
+    "additionalProperties": False,
+}
+
+# top-level anyOf/oneOf/allOf/if are rejected by the api; quick.py's validate_classification() enforces the
+# classify-branch fields instead
+TRIAGE_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "action": {"type": "string", "enum": ["answer", "classify"]},
+        "answer": {"type": "string"},
+        **CLASSIFICATION_SCHEMA["properties"],
+    },
+    "required": ["action", "answer"],
+    "additionalProperties": False,
+}
+
+
+def trim_context(context: str | None, max_chars: int = 1500) -> str | None:
+    if not context or len(context) <= max_chars:
+        return context
+    marker = "(earlier messages omitted)\n"
+    return marker + context[-(max_chars - len(marker)) :]
+
+
+def classification_guidance(approved_repos: list[str], integrations: list[str], self_repo_line: str = "") -> str:
+    """shared task_type/complexity/jira-key rules used by both classifier_prompt and triage_prompt (issue #41) —
+    keep routing rules here so a future change only has to be made in one place."""
+    return f"""Approved repositories (only these may appear in target_repos): {json.dumps(approved_repos)}{self_repo_line}
+Available integrations: {json.dumps(integrations)}
+
+Engineering questions count as task_type "question" even when there is nothing to execute
+(e.g. "what does HTTP 429 mean?"). Use "unsupported" only for requests with no engineering content at all
+(greetings, chit-chat) or things this system must not do. Closing a pull request and/or deleting its
+(non-protected, agent/-prefixed) branch are supported engineering operations — classify these as "bug_fix", not "unsupported".
+Requests to address, fix, or respond to review comments on a pull request are code changes — classify them
+as "bug_fix", not "pr_review"; "pr_review" is only for actually reviewing a pull request.
+Complexity guide: trivial = single-step lookups; standard = routine engineering; complex = multi-file or
+multi-system work needing sustained reasoning; critical is rare and means a mistake is very costly or the
+reasoning is unusually deep, such as architecture changes, security-sensitive fixes, or data-corruption and
+concurrency bugs.
+Effort sets how much reasoning depth the sub-agent uses: low for trivial lookups, medium or high to match
+routine-to-complex engineering, xhigh or max only for unusually deep reasoning (as rare as "critical"
+complexity). Use "auto" when you have no opinion — the routed profile's own default effort applies instead.
+Jira keys look like PROJ-123; extract them only if actually referenced."""
+
+
+def classifier_prompt(request_text: str, approved_repos: list[str], integrations: list[str], thread_context: str | None = None, self_repo: str | None = None, bot_name: str = "Agent") -> str:
+    context = f"\nConversation in the Slack thread where this was requested (context only — classify the request above):\n{thread_context}\n" if thread_context else ""
+    self_repo_line = f'\nThe repository "{self_repo}" is {bot_name}\'s own source code (this agent). Requests about {bot_name} itself — "you", "your code", "yourself" — target it.' if self_repo else ""
+    return f"""You classify one engineering request for routing. Do not attempt the task.
+
+Request:
+{request_text}
+{context}
+
+Classify the request.
+
+{classification_guidance(approved_repos, integrations, self_repo_line)}"""
+
+
+def quick_answer_prompt(request_text: str, bot_name: str, task_context: str | None, personality: str | None = None) -> str:
+    context = task_context or "No task-status context was referenced."
+    voice = f"\nPersonality for the answer text:\n{personality}\n" if personality else ""
+    return f"""You are {bot_name}'s fast answer path. Return only the requested structured output.
+{voice}
+
+Request:
+{request_text}
+
+Task-status context, if any:
+{context}
+
+Answer only simple general or engineering knowledge, or questions answerable directly from the task-status
+context above. Escalate anything needing repositories, tools, writes, external systems, or investigation.
+For an escalation set answer to an empty string."""
+
+
+def dm_chat_prompt(request_text: str, bot_name: str, history: str | None = None, personality: str | None = None) -> str:
+    conversation = history or "No earlier direct-message context is available."
+    voice = f"\nPersonality for the answer text:\n{personality}\n" if personality else ""
+    return f"""You are {bot_name}, chatting directly with a user in Slack. Return only the requested structured output.
+{voice}
+
+Recent direct-message conversation (context only):
+{conversation}
+
+Newest user message:
+{request_text}
+
+Answer conversationally and directly when the request needs only general knowledge or discussion. Use action
+"escalate" and set answer to an empty string for anything that needs repositories, tools, writes, external
+systems, or investigation. The caller will explain how to start a full task; never claim that you started one."""
+
+
+def triage_prompt(
+    request_text: str,
+    bot_name: str,
+    task_context: str | None,
+    approved_repos: list[str],
+    integrations: list[str],
+    thread_context: str | None = None,
+    personality: str | None = None,
+    self_repo: str | None = None,
+) -> str:
+    task_status = task_context or "No task-status context was referenced."
+    thread = f"\nConversation in the Slack thread (context only):\n{thread_context}\n" if thread_context else ""
+    voice = f"\nPersonality for the answer text:\n{personality}\n" if personality else ""
+    self_repo_line = f'\nThe repository "{self_repo}" is {bot_name}\'s own source code (this agent). Requests about {bot_name} itself — "you", "your code", "yourself" — target it.' if self_repo else ""
+    return f"""You are {bot_name}'s fast triage path. Return only the requested structured output.
+{voice}
+
+Request:
+{request_text}
+{thread}
+
+Task-status context, if any:
+{task_status}
+
+Answer only simple general or engineering knowledge, or questions answerable directly from the task-status
+context above. Greetings and small talk (e.g. "hi", "thanks", "how are you") also get action "answer" with a
+short, friendly conversational reply — never classify them. Anything needing repositories, tools, writes,
+external systems, or investigation must use action "classify" and set answer to an empty string. For action
+"answer", put the complete concise reply in answer; classification fields may be omitted.
+
+For action "classify", include every classification field and follow this guidance:
+
+{classification_guidance(approved_repos, integrations, self_repo_line)}"""
+
+
+def task_prompt(
+    task: Task,
+    parent_summary: str | None,
+    prior_artifacts: list[dict],
+    github: bool = False,
+    bot_name: str = "Agent",
+    other_bot_name: str = "Reviewer",
+    is_reviewer: bool = False,
+    thread_context: str | None = None,
+    failed_repo_clones: list[str] | None = None,
+    cloned_repos: list[str] | None = None,
+    skill: dict | None = None,
+    conventions: bool = False,
+    personality: str | None = None,
+    self_repo: str | None = None,
+    granted_permissions: dict | None = None,
+    jira: bool = False,
+    answered_questions: list[dict] | None = None,
+) -> str:
+    sections = [
+        f"""You are {bot_name}, an autonomous engineering agent (system: taskboy). You are working on task `{task.task_id}`, requested by <@{task.slack_user_id}> in Slack.
+
+## Request
+{task.request_text}""",
+    ]
+    if skill:
+        args = skill.get("args") or "(none)"
+        sections.append(
+            f"""## Skill invocation
+This request invokes the /{skill['name']} skill. Follow the skill instructions below exactly. They take precedence over conflicting general guidance, except the safety rules and the Final Report requirement.
+
+Arguments: {args}
+
+### Skill: /{skill['name']}
+{skill['instructions']}"""
+        )
+    if parent_summary:
+        sections.append(f"## Context from the previous task in this thread\n{parent_summary}")
+    if thread_context:
+        sections.append(f"## Conversation in this Slack thread\n{thread_context}")
+    if answered_questions:
+        rounds = "\n\n".join(f"You asked:\n{row['questions']}\n\nThe requester answered:\n{row['answer_text'] or ''}" for row in answered_questions)
+        sections.append(
+            f"""## Answers from the requester
+You previously asked the requester follow-up questions and they have answered. Work from these answers; do not re-ask them.
+
+{rounds}"""
+        )
+    if prior_artifacts:
+        listing = "\n".join(f"- {a['kind']}: {a['external_id']}" + (f" ({a['url']})" if a.get("url") else "") for a in prior_artifacts)
+        sections.append(f"## Artifacts that already exist for this task — update them, never recreate them\n{listing}")
+    if github:
+        other_persona = other_bot_name
+        jira_keys = (json.loads(task.classification_json) if task.classification_json else {}).get("jira_keys") or []
+        jira_line = f"\n- A Jira issue is referenced ({', '.join(jira_keys)}): include its key in the branch name and pull request title." if jira_keys else ""
+        cloned_line = ""
+        if cloned_repos:
+            paths = ", ".join(f"./{repo.split('/')[-1]}" for repo in cloned_repos)
+            cloned_line = f"\n- These repositories are already cloned in your workspace: {paths} — work in them directly; fetch/pull/push work normally (auth handled)."
+        failed_clone_line = ""
+        if failed_repo_clones:
+            names = ", ".join(failed_repo_clones)
+            failed_clone_line = f"\n- These target repos could not be pre-cloned (clone them yourself with git; auth is handled): {names}."
+        self_repo_line = f"\n- {self_repo} is your own source code — the service you are running as. Changes merged to main deploy automatically. Work only on your `agent/` branch and open a pull request for human review; never attempt to merge it yourself." if self_repo else ""
+        no_delegate_line = (
+            f"\n- When your job is to change code — including addressing pull request review comments — make the changes yourself. Do not request a {other_persona} review or spawn {other_persona}; {other_persona} reviews pull requests only through the GitHub review-request flow."
+            if not is_reviewer
+            else ""
+        )
+        sections.append(
+            f"""## GitHub work rules
+- Use git via Bash for clone/commit/push (auth is handled for you); use the mcp__github__* tools for pull request operations.
+- Create branches named `agent/{task.task_id}-<short-slug>`. Pushes may only target `agent/` branches — anything else is blocked at multiple layers and will fail.
+- Docker is available: build and run project images and Makefile targets that use docker compose as needed.
+- Before pushing code changes, run the repository's checks — `make check` (lint, format, mypy, tests) when the Makefile defines it — and fix failures until they pass. Never push code that fails its checks.
+- When you change code to address a pull request review comment, reply to that comment with mcp__github__reply_to_pr_comment as {bot_name}: one or two plain sentences saying what you changed and why it fixes the finding. Only resolve a review thread with mcp__github__resolve_pr_thread that you or {other_persona} started, and only once the code verifiably fixes it.
+- Pull request bodies must contain: Summary, Testing performed, Known limitations. Before opening a PR, check whether one already exists for your branch.
+- Include the pull request link in your `## Reply` when you opened or reviewed one.{no_delegate_line}{jira_line}{cloned_line}{failed_clone_line}{self_repo_line}"""
+        )
+    if jira:
+        sections.append(
+            """## Jira work rules
+- When the request asks you to work on a referenced Jira issue, transition it to `In Progress` with `mcp__jira__transition_issue` before you begin implementation, and include the issue link in your `## Reply`.
+- When you create a Jira issue for engineering work, state the repositories the work will involve directly in the issue description (a `Repositories:` line listing them, or `Repositories: unknown` if it truly can't be determined) so the story clearly names where the work lands.
+- When you create, update, or otherwise alter a Jira issue, include its link in your `## Reply`."""
+        )
+    if conventions:
+        sections.append(
+            f"""## Engineering conventions
+Your organization's engineering conventions are in `./{CONVENTIONS_FILENAME}` in your workspace. Before writing, changing, or reviewing any code in the repositories, read that file and follow it — it is ground truth for how this organization's services are structured, coded, tested, and deployed. For read-only questions, consult it whenever conventions are relevant to the answer."""
+        )
+    if granted_permissions and (granted_permissions.get("tools") or granted_permissions.get("repos")):
+        lines = [f"- tool: {name}" for name in granted_permissions.get("tools") or []] + [f"- repo: {name}" for name in granted_permissions.get("repos") or []]
+        listing = "\n".join(lines)
+        sections.append(
+            f"""## Granted permissions
+An operator granted these additional permissions for this task; they are active now, so use them to finish the work you previously requested them for:
+{listing}"""
+        )
+    if personality:
+        sections.append(
+            f"""## Personality
+Use this voice only for the requester-facing `## Reply`. Keep the internal Final Report factual and structured. Personality governs voice, not length or structure — the Reply length/format rule below always wins over any brevity guidance here (e.g. "keep replies to a sentence or two").
+
+{personality}"""
+        )
+    report_style = task.task_type in ("question", "investigation", "incident_diagnosis")
+    reply_rule = (
+        """`## Reply`: this task's type was classified as question, investigation, or incident_diagnosis — the deliverable is information, not a code change. Put the complete findings here, not a pointer to the Final Report: a short TLDR at the top, then the full detail as well-spaced bullet points. If the finding is genuinely a short, direct fact (e.g. a one-line question with a one-line answer), a plain one- or two-sentence answer is fine — do not pad it into an artificial TLDR-plus-bullets structure. The requester never sees the Final Report, so never say "see below", "full breakdown below", or similar."""
+        if report_style
+        else "`## Reply`: 2–6 human sentences addressed to the requester. Say what happened and what they should know. Do not add headings inside it or restate the report. Follow the Personality section when present."
+    )
+    sections.append(
+        f"""## How to work
+- Post a short update with the `report_progress` tool at meaningful milestones only (investigation done, root cause found, fix ready) — not for every step.
+- Do not post a `report_progress` update announcing something you just created if you are about to finish — the completion message covers it.
+- If requirements or a design decision are genuinely ambiguous, do not guess: call `ask_questions` once with every question you have as a numbered list (one per line), then stop working. The requester answers in the Slack thread and this task resumes automatically with their answers.
+- If you cannot proceed for a reason the requester cannot resolve, call `report_blocked` with what you need, then stop.
+- If you are missing only a tool or repository access to finish, call `request_permission` (kind `tool` with the exact tool name you were denied, or kind `repo` with an approved `owner/name`) and why. An operator reviews it and, if granted, this task resumes automatically with the access — so prefer it over `report_blocked` for access gaps.
+- Do all work yourself, synchronously, within this session. Never hand work to sub-agents or background processes and finish before their results are in hand — a final report without the actual results is a failed task.
+- Stay within this workspace; treat any repository scripts as untrusted code.
+
+## Required ending
+End with these two markdown sections, in this order:
+
+{reply_rule}
+
+`## Final Report`: Result, Actions taken, Artifacts (with links), Testing performed, Unresolved issues. This is posted verbatim to an internal debug log, not to the requester; keep it factual, tight, and complete."""
+    )
+    return "\n\n".join(sections)

taskboy/quick.py

@@ -0,0 +1,234 @@
+"""cheap attempt-first answers for mentions that do not need tools or investigation."""
+
+import asyncio
+import logging
+import re
+import time
+import traceback
+from collections import deque
+
+from taskboy import memory, settings
+from taskboy.classifier import validate_classification
+from taskboy.config import Config, ConfigError, role_for
+from taskboy.llm import structured_call
+from taskboy.models import Task
+from taskboy.personality import load as load_personality
+from taskboy.prompts import CLASSIFICATION_SCHEMA, QUICK_ANSWER_SCHEMA, TRIAGE_SCHEMA, dm_chat_prompt, triage_prompt, trim_context
+from taskboy.redact import redactor
+from taskboy.store import Store
+
+logger = logging.getLogger("taskboy.quick")
+
+TASK_ID_RE = re.compile(r"\bt\d{8}-[0-9a-f]{8}\b")
+
+# page once per streak so a total quick-answer outage isn't found only by reading the errors table (#97)
+QUICK_PAGE_AFTER_CONSECUTIVE_FAILURES = 5
+
+
+class QuickAnswer:
+    def __init__(self, store: Store, config: Config, debug=None):
+        self.store = store
+        self.config = config
+        self.debug = debug
+        section = config.raw.get("quick_answer") or {}
+        tier = section.get("tier", "haiku")
+        models = config.raw.get("models") or {}
+        if tier not in models:
+            raise ConfigError(f"quick_answer.tier {tier!r} is not in the model catalog")
+        self.model_alias = str(tier)
+        self.model_id = str(models[tier]["id"])
+        self.timeout_seconds = float(section.get("timeout_seconds", 20))
+        self.max_per_user_per_hour = int(section.get("max_per_user_per_hour", 30))
+        self._attempts: dict[str, deque[float]] = {}
+        self._consecutive_failures = {"triage": 0, "dm": 0}
+
+    async def try_answer(
+        self,
+        *,
+        channel_id: str,
+        thread_ts: str,
+        user_id: str,
+        text: str,
+        parent: Task | None,
+        team_id: str,
+        message_ts: str,
+        thread_context: str | None = None,
+        debug_thread_ts: str | None = None,
+        debug_permalink: str | None = None,
+    ) -> tuple[Task | None, dict | None]:
+        """return either a recorded answer task or a reusable classification."""
+        started = time.monotonic()
+        try:
+            if not self._allow_attempt(user_id, started):
+                logger.info("quick answer rate cap reached for %s", user_id)
+                return None, None
+            context = self._task_context(text, parent)
+            personality = load_personality(self.config.personality_path)
+            github = (self.config.raw.get("github") or {}) if self.config.service_enabled("github") else {}
+            approved_repos = github.get("approved_repos") or []
+            role = role_for(self.config.roles, user_id)
+            if role is not None and role.repos is not None:
+                approved_repos = [repo for repo in approved_repos if repo in role.repos]
+            self_repo = str(github.get("self_repo") or "")
+            prompt = triage_prompt(
+                redactor.redact(text)[:6000],
+                self.config.agent_name,
+                context,
+                approved_repos,
+                self.config.enabled_integrations(),
+                trim_context(thread_context),
+                personality[0] if personality else None,
+                self_repo if self_repo in approved_repos else None,
+            )
+            async with asyncio.timeout(self.timeout_seconds):
+                result, usage = await self._call_model(prompt)
+            if result.get("action") == "classify":
+                validated = validate_classification(result)
+                classification = {key: validated[key] for key in CLASSIFICATION_SCHEMA["required"]}
+                if usage:
+                    classification["_triage_usage"] = usage
+                self._consecutive_failures["triage"] = 0
+                return None, classification
+            if result.get("action") != "answer" or not str(result.get("answer") or "").strip():
+                self._consecutive_failures["triage"] = 0
+                return None, None
+            answer = str(result["answer"]).strip()
+            latency = time.monotonic() - started
+            task = self.store.record_quick_answer(
+                slack_team_id=team_id,
+                slack_channel_id=channel_id,
+                slack_thread_ts=thread_ts,
+                slack_message_ts=message_ts,
+                slack_user_id=user_id,
+                request_text=text,
+                answer_text=answer,
+                model_alias=self.model_alias,
+                model_id=self.model_id,
+                parent_task_id=parent.task_id if parent else None,
+                latency_s=latency,
+                debug_thread_ts=debug_thread_ts,
+                debug_permalink=debug_permalink,
+            )
+            if personality:
+                self.store.add_event(task.task_id, "personality", {"hash": personality[1], "path": self.config.personality_path})
+            if usage:
+                self.store.add_usage(task.task_id, "quick_answer", self.model_id, **usage)
+            logger.info("quick answer completed for %s in %.3fs", task.task_id, latency)
+            self._consecutive_failures["triage"] = 0
+            return task, None
+        except Exception as e:
+            logger.warning("quick answer escalated after failure: %s", e)
+            self.store.add_error("quick_answer", type(e).__name__, str(e), traceback=traceback.format_exc(), context={"user_id": user_id, "channel_id": channel_id})
+            await self._on_model_failure("triage", str(e))
+            return None, None
+
+    async def chat(
+        self,
+        *,
+        channel_id: str,
+        user_id: str,
+        text: str,
+        team_id: str,
+        message_ts: str,
+        history: str | None = None,
+    ) -> tuple[Task | None, str]:
+        """Answer one DM without ever creating a queued task."""
+        started = time.monotonic()
+        if not self._allow_attempt(user_id, started):
+            logger.info("quick chat rate cap reached for %s", user_id)
+            return None, "rate_limited"
+        try:
+            personality = load_personality(self.config.personality_path)
+            prompt = dm_chat_prompt(
+                redactor.redact(text)[:6000],
+                self.config.agent_name,
+                trim_context(history, 6000),
+                personality[0] if personality else None,
+            )
+            async with asyncio.timeout(self.timeout_seconds):
+                result, usage = await self._call_chat_model(prompt)
+            if result.get("action") != "answer" or not str(result.get("answer") or "").strip():
+                self._consecutive_failures["dm"] = 0
+                return None, "escalate"
+            answer = str(result["answer"]).strip()
+            task = self.store.record_quick_answer(
+                slack_team_id=team_id,
+                slack_channel_id=channel_id,
+                slack_thread_ts=message_ts,
+                slack_message_ts=message_ts,
+                slack_user_id=user_id,
+                request_text=text,
+                answer_text=answer,
+                model_alias=self.model_alias,
+                model_id=self.model_id,
+                latency_s=time.monotonic() - started,
+            )
+            if personality:
+                self.store.add_event(task.task_id, "personality", {"hash": personality[1], "path": self.config.personality_path})
+            if usage:
+                self.store.add_usage(task.task_id, "quick_answer", self.model_id, **usage)
+            self._consecutive_failures["dm"] = 0
+            return task, "answer"
+        except Exception as e:
+            logger.warning("quick chat escalated after failure: %s", e)
+            self.store.add_error("quick_answer", type(e).__name__, str(e), traceback=traceback.format_exc(), context={"user_id": user_id, "channel_id": channel_id, "mode": "dm"})
+            await self._on_model_failure("dm", str(e))
+            return None, "escalate"
+
+    async def _on_model_failure(self, path: str, message: str) -> None:
+        """page the debug channel once per streak, per path, once failures reach the threshold."""
+        self._consecutive_failures[path] += 1
+        count = self._consecutive_failures[path]
+        if count == QUICK_PAGE_AFTER_CONSECUTIVE_FAILURES and self.debug is not None:
+            await self.debug.system_error("quick_answer", f"quick answer {path} path has failed {count} times in a row: {message}")
+
+    def _allow_attempt(self, user_id: str, now: float) -> bool:
+        cutoff = now - 3600
+        for existing_user, existing_attempts in list(self._attempts.items()):
+            while existing_attempts and existing_attempts[0] <= cutoff:
+                existing_attempts.popleft()
+            if not existing_attempts:
+                del self._attempts[existing_user]
+        attempts = self._attempts.setdefault(user_id, deque())
+        if len(attempts) >= self.max_per_user_per_hour:
+            return False
+        attempts.append(now)
+        return True
+
+    def _task_context(self, text: str, parent: Task | None) -> str | None:
+        blocks: list[str] = []
+        seen: set[str] = set()
+        if parent is not None:
+            blocks.append(_task_block(parent, memory.read_summary(settings.MEMORY_ROOT, parent.task_id)))
+            seen.add(parent.task_id)
+        for task_id in TASK_ID_RE.findall(text)[:3]:
+            if task_id in seen:
+                continue
+            task = self.store.get_task(task_id)
+            if task is not None:
+                blocks.append(_task_block(task, memory.read_summary(settings.MEMORY_ROOT, task.task_id)))
+                seen.add(task_id)
+        return "\n\n".join(blocks) or None
+
+    async def _call_model(self, prompt: str) -> tuple[dict, dict | None]:
+        """the per-call API seam, kept conversation-free and patched in tests."""
+        return await structured_call(self.model_id, prompt, TRIAGE_SCHEMA)
+
+    async def _call_chat_model(self, prompt: str) -> tuple[dict, dict | None]:
+        return await structured_call(self.model_id, prompt, QUICK_ANSWER_SCHEMA)
+
+
+def _task_block(task: Task, summary: str | None) -> str:
+    detail = task.result_summary or task.error or task.blocked_reason or ""
+    lines = [
+        f"task {task.task_id}",
+        f"state: {task.state}",
+        f"model: {task.model_alias or 'n/a'}",
+        f"created: {task.created_at}",
+        f"finished: {task.finished_at or 'n/a'}",
+    ]
+    if detail:
+        lines.append(f"result/error: {detail[:500]}")
+    if summary:
+        lines.append(f"memory summary: {summary[:500]}")
+    return redactor.redact("\n".join(lines))[:1500]

taskboy/redact.py

@@ -0,0 +1,49 @@
+"""secret redaction, applied at the durable/outbound sinks: task-row text fields, audit events, slack posts, memory files (§8.2, MEM-011).
+
+two mechanisms: pattern rules for known token families, and an exact-match registry of live
+secret values — every loaded or minted credential is registered so it can never survive any sink.
+"""
+
+import re
+
+# (pattern, replacement) — replacement keeps any labeled prefix group
+PATTERNS: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"ghp_[A-Za-z0-9]{20,}"), "[redacted]"),  # github classic pat
+    (re.compile(r"ghs_[A-Za-z0-9]{20,}"), "[redacted]"),  # github app installation token
+    (re.compile(r"gho_[A-Za-z0-9]{20,}"), "[redacted]"),  # github oauth token
+    (re.compile(r"github_pat_[A-Za-z0-9_]{20,}"), "[redacted]"),  # github fine-grained pat
+    (re.compile(r"xox[baprse]-[A-Za-z0-9-]{10,}"), "[redacted]"),  # slack bot/user tokens
+    (re.compile(r"xapp-[A-Za-z0-9-]{10,}"), "[redacted]"),  # slack app-level token
+    (re.compile(r"\b(?:AKIA|ASIA|ABIA|ACCA|A3T[A-Z0-9])[A-Z0-9]{16}\b"), "[redacted]"),  # aws access key ids
+    (re.compile(r"sk-ant-[A-Za-z0-9_-]{10,}"), "[redacted]"),  # anthropic api keys
+    (re.compile(r"sntrys_[A-Za-z0-9_+/=.-]{10,}"), "[redacted]"),  # sentry org tokens
+    (re.compile(r"eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+"), "[redacted]"),  # jwts
+    (re.compile(r"(?i)(authorization:\s*(?:bearer|basic)\s+)\S+"), r"\1[redacted]"),
+    (re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----"), "[redacted private key]"),
+]
+
+
+class Redactor:
+    def __init__(self):
+        self._values: set[str] = set()
+
+    def register(self, value: str | None) -> None:
+        """exact-match redaction for a live secret value (loaded from the bundle or minted by the broker)."""
+        if value and len(value) >= 8:  # refuse tiny values that would shred normal text
+            self._values.add(value)
+
+    def unregister(self, value: str | None) -> None:
+        self._values.discard(value or "")
+
+    def redact(self, text: str) -> str:
+        if not text:
+            return text
+        for value in self._values:
+            text = text.replace(value, "[redacted]")
+        for pattern, replacement in PATTERNS:
+            text = pattern.sub(replacement, text)
+        return text
+
+
+# process-wide instance: secrets.load_secrets() registers values, sinks call redactor.redact()
+redactor = Redactor()