fix(slack): Restore first-thread status and trim short continuations (#206)

Restore the Slack thread delivery regressions from the streaming
overhaul and tighten the contracts around them.

For the first non-DM thread message we were only resolving assistant
thread context from raw `thread_ts`, which meant status updates did not
attach until after the first reply already existed. This changes non-DM
resolution to use `thread_ts ?? ts`, keeps `message.im` strict about
explicit `thread_ts`, and adds regression coverage for the first-message
channel thread path.

This also drops the `[Continued below]` marker when a reply only spans
two Slack posts. That marker was only helpful for longer continuations
and added noise in ordinary short thread replies.

While touching these contracts, the PR updates the local Slack
skill/docs to synthesize the Slack assistant-thread APIs we rely on,
rewrites the eval authoring pattern around maintainer-readable describe
blocks, case names, and `rubric({ contract, pass, allow, fail })`
criteria, and imports a root `policies/` directory with explicit
`AGENTS.md` references so repo-wide defaults can live in small policy
docs instead of growing the root agent instructions.

---------

Co-authored-by: GPT-5 Codex <noreply@openai.com>

Author: dcramer

.agents/skills/slack-development/SKILL.md

@@ -9,15 +9,15 @@ Implement Slack-facing behavior with predictable formatting, inbound routing, an
 
 Determine which category applies before writing code:
 
-| Category                  | Typical request                                                                                                                                 | Primary reference                                                                                                                                                                                           |
-| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Output formatting         | "Fix markdown", "why does Slack render this weirdly?"                                                                                           | `${CLAUDE_SKILL_ROOT}/references/slack-output-formatting.md`                                                                                                                                                |
-| Slack event payloads      | "What does Slack send?", "why did raw event parsing fail?"                                                                                      | `${CLAUDE_SKILL_ROOT}/references/slack-inbound-message-formats.md`                                                                                                                                          |
-| Chat SDK payload contract | "What fields do handlers actually receive?", "which fields are reliable in `onSubscribedMessage`?"                                              | `${CLAUDE_SKILL_ROOT}/references/chat-sdk-payload-contract.md`                                                                                                                                              |
-| Thread routing            | "Passive detector skips thread replies", "reply/no-reply logic is wrong"                                                                        | `${CLAUDE_SKILL_ROOT}/references/slack-thread-routing.md`                                                                                                                                                   |
-| Assistant-thread APIs     | "Why does `assistant.threads.setStatus` fail?", "should this DM have assistant status/title?", "does Chat tab DM count as an assistant thread?" | Read Slack docs for `assistant_thread_started`, `assistant_thread_context_changed`, `message.im`, and `assistant.threads.*` first, then load `${CLAUDE_SKILL_ROOT}/references/chat-sdk-payload-contract.md` |
-| Long-running behavior     | "No feedback while it runs", "show progress", "stream output"                                                                                   | `${CLAUDE_SKILL_ROOT}/references/chat-sdk-patterns.md`                                                                                                                                                      |
-| Multiple categories       | Change touches formatting, routing, and/or runtime UX                                                                                           | Read only the needed references above                                                                                                                                                                       |
+| Category                  | Typical request                                                                                                                                 | Primary reference                                                                                                                                                                                                                                                          |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Output formatting         | "Fix markdown", "why does Slack render this weirdly?"                                                                                           | `${CLAUDE_SKILL_ROOT}/references/slack-output-formatting.md`                                                                                                                                                                                                               |
+| Slack event payloads      | "What does Slack send?", "why did raw event parsing fail?"                                                                                      | `${CLAUDE_SKILL_ROOT}/references/slack-inbound-message-formats.md`                                                                                                                                                                                                         |
+| Chat SDK payload contract | "What fields do handlers actually receive?", "which fields are reliable in `onSubscribedMessage`?"                                              | `${CLAUDE_SKILL_ROOT}/references/chat-sdk-payload-contract.md`                                                                                                                                                                                                             |
+| Thread routing            | "Passive detector skips thread replies", "reply/no-reply logic is wrong"                                                                        | `${CLAUDE_SKILL_ROOT}/references/slack-thread-routing.md`                                                                                                                                                                                                                  |
+| Assistant-thread APIs     | "Why does `assistant.threads.setStatus` fail?", "should this DM have assistant status/title?", "does Chat tab DM count as an assistant thread?" | Read Slack docs for `assistant_thread_started`, `assistant_thread_context_changed`, `message.im`, and `assistant.threads.*` first, then load `${CLAUDE_SKILL_ROOT}/references/assistant-thread-apis.md` and `${CLAUDE_SKILL_ROOT}/references/chat-sdk-payload-contract.md` |
+| Long-running behavior     | "No feedback while it runs", "show progress", "stream output"                                                                                   | `${CLAUDE_SKILL_ROOT}/references/chat-sdk-patterns.md`                                                                                                                                                                                                                     |
+| Multiple categories       | Change touches formatting, routing, and/or runtime UX                                                                                           | Read only the needed references above                                                                                                                                                                                                                                      |
 
 If the request is ambiguous, ask one focused question and continue after clarification.
 
@@ -27,7 +27,7 @@ Use the selected reference files as the implementation guide. Keep SKILL.md high
 
 Slack assistant-thread guardrails:
 
-1. Use Slack's current inbound event payload as the source of truth for assistant-thread API calls. For `message.im`, require the live `channel` and explicit `thread_ts`. For lifecycle events, use `assistant_thread.channel_id` and `assistant_thread.thread_ts`.
+1. Use Slack's current inbound event payload as the source of truth for assistant-thread API calls. For non-DM message events, use the live `channel` plus `thread_ts ?? ts`. For `message.im`, require the live `channel` and explicit `thread_ts`. For lifecycle events, use `assistant_thread.channel_id` and `assistant_thread.thread_ts`.
 2. Do not invent assistant-thread identifiers from persisted state unless Slack's docs explicitly require it.
 3. Separate reply continuity from assistant-thread API eligibility. A stored root timestamp can be valid for reply threading without being valid for `assistant.threads.*`.
 4. Treat `assistant_thread_started` and `assistant_thread_context_changed` differently. Context changes can refresh prompts/context, but should not clobber a conversation-specific thread title back to a generic default.
@@ -51,7 +51,7 @@ Use this checklist:
 - Rendering: message examples render correctly in Slack (`mrkdwn` expectations, escapes, mentions/links).
 - Inbound formats: routing uses documented Chat SDK payload fields first; raw Slack parsing only when necessary.
 - Thread routing: explicit bot mention paths bypass passive no-reply classification.
-- Assistant threads: `assistant.threads.*` calls use the live inbound assistant-thread context; `message.im` must carry explicit `thread_ts`, and runtime code does not synthesize assistant roots for status/title updates.
+- Assistant threads: `assistant.threads.*` calls use the live inbound assistant-thread context; non-DM message events may use `thread_ts ?? ts`, `message.im` must carry explicit `thread_ts`, and runtime code does not synthesize DM assistant roots for status/title updates.
 - Accessibility: block messages include an adequate top-level fallback `text` strategy.
 - Latency UX: user sees immediate feedback for long-running tasks.
 - Streaming/progress: behavior is observable during tool/model execution, not only at completion.

.agents/skills/slack-development/references/assistant-thread-apis.md

@@ -0,0 +1,140 @@
+# Assistant-Thread APIs
+
+## Scope
+
+Canonical local synthesis of the Slack and Chat SDK APIs this repository
+relies on for Slack assistant-thread lifecycle, status, and title behavior.
+
+Use this file before changing:
+
+- assistant-thread status/title behavior
+- DM versus channel-thread Slack context handling
+- assistant lifecycle event handling
+- Slack skill guidance that refers to `assistant.threads.*`
+
+This file intentionally separates:
+
+1. vendor-documented API facts
+2. repository policy layered on top
+3. concrete implementation seams in this repo
+
+## External API Surfaces We Rely On
+
+### Slack Events API
+
+1. `app_mention`
+
+- Used for explicit mentions in channels.
+- Carries `channel`, `ts`, and optional `thread_ts`.
+- Messages in direct messages are not delivered through `app_mention`.
+
+2. `message.im`
+
+- Used for DM traffic to the bot.
+- Carries `channel`, `ts`, and may omit `thread_ts` on the first DM message.
+- Slack AI/app-thread continuation in DMs depends on `thread_ts` when present.
+
+3. `assistant_thread_started`
+
+- Carries `assistant_thread.channel_id`, `assistant_thread.thread_ts`, and optional `assistant_thread.context.channel_id`.
+- Used to initialize suggested prompts and thread-title state for Slack assistant threads.
+
+4. `assistant_thread_context_changed`
+
+- Carries the same `assistant_thread.*` shape as the start event.
+- Used to refresh context without resetting an established conversation title.
+
+### Slack Web API
+
+1. `assistant.threads.setStatus`
+
+- Requires `channel_id` and `thread_ts`.
+- Slack clears status automatically when a reply is posted.
+- Sending an empty `status` clears the indicator explicitly.
+- Slack currently accepts either `chat:write` or `assistant:write` for this method. This changed in March 2026 and may change again, so re-check the live docs before changing scope guidance.
+
+2. `assistant.threads.setTitle`
+
+- Requires `channel_id`, `thread_ts`, and `title`.
+- Still documented as an assistant-thread/title API, primarily for app-thread history in DMs.
+- `assistant:write` remains the documented scope for this method.
+
+3. `assistant.threads.setSuggestedPrompts`
+
+- Requires `channel_id`, `thread_ts`, and prompt payloads.
+- Used from the lifecycle path when Slack starts or refreshes an assistant thread.
+
+### Chat SDK Slack Adapter
+
+1. `setAssistantStatus(channelId, threadTs, status, loadingMessages?)`
+
+- Thin adapter wrapper around Slack `assistant.threads.setStatus`.
+
+2. `setAssistantTitle(channelId, threadTs, title)`
+
+- Thin adapter wrapper around Slack `assistant.threads.setTitle`.
+
+3. `startTyping(threadId, status?)`
+
+- Available in the adapter, but this repository does not use it as the baseline visible Slack progress surface.
+
+## Repository Policy
+
+1. Assistant status is the primary in-flight progress surface. Visible reply text is finalized before posting.
+2. For non-DM message events, the live assistant-thread key is `channel + (thread_ts ?? ts)`.
+3. For `message.im`, assistant-thread status/title updates require an explicit live `thread_ts`. Do not synthesize DM assistant roots from generic `ts` or persisted state.
+4. For lifecycle events, use `assistant_thread.channel_id + assistant_thread.thread_ts`.
+5. Reply continuity and assistant-thread API eligibility are separate concerns. A persisted thread root can be valid for reply threading without being valid for `assistant.threads.*`.
+6. Conversation-specific thread titles are DM-only in the normal reply path and come from the earliest human message the runtime actually knows about for that thread.
+7. `assistant_thread_context_changed` may refresh prompts/context, but must not clobber an already established conversation title.
+
+## Implementation Map In This Repo
+
+1. Live assistant-thread context selection:
+
+- `packages/junior/src/chat/runtime/thread-context.ts`
+- `getAssistantThreadContext()`
+
+2. Status sending and token binding:
+
+- `packages/junior/src/chat/slack/assistant-thread/status-send.ts`
+- `packages/junior/src/chat/slack/assistant-thread/status.ts`
+- `packages/junior/src/chat/slack/assistant-thread/status-scheduler.ts`
+
+3. Lifecycle event handling:
+
+- `packages/junior/src/chat/slack/assistant-thread/lifecycle.ts`
+- `packages/junior/src/chat/runtime/slack-runtime.ts`
+
+4. DM title generation and permission handling:
+
+- `packages/junior/src/chat/slack/assistant-thread/title.ts`
+
+5. Current delivery contract:
+
+- `specs/slack-agent-delivery-spec.md`
+
+## Audit Checklist
+
+When changing code or guidance in this area, verify all of the following:
+
+1. `app_mention` handling does not treat channel traffic like `message.im`.
+2. Channel-thread first replies use the live `ts` when `thread_ts` is absent.
+3. DM status/title updates are skipped when the current `message.im` lacks explicit `thread_ts`.
+4. Lifecycle events use `assistant_thread.channel_id` and `assistant_thread.thread_ts`.
+5. `assistant.threads.setStatus` calls never receive adapter-scoped `slack:<channel>` IDs.
+6. Title generation stays best effort and does not block visible reply delivery.
+7. Skill/docs wording does not hardcode stale scope assumptions for `setStatus`.
+
+## Sources
+
+- Slack `app_mention`: https://docs.slack.dev/reference/events/app_mention/
+- Slack `message.im`: https://docs.slack.dev/reference/events/message.im
+- Slack `assistant_thread_started`: https://docs.slack.dev/reference/events/assistant_thread_started
+- Slack `assistant_thread_context_changed`: https://docs.slack.dev/reference/events/assistant_thread_context_changed/
+- Slack `assistant.threads.setStatus`: https://docs.slack.dev/reference/methods/assistant.threads.setStatus
+- Slack `assistant.threads.setTitle`: https://docs.slack.dev/reference/methods/assistant.threads.setTitle
+- Slack status scope update: https://docs.slack.dev/changelog/2026/03/05/set-status-scope-update/
+- Slack `chat:write` scope: https://docs.slack.dev/reference/scopes/chat.write/
+- Slack AI app guidance: https://docs.slack.dev/ai/developing-ai-apps
+- Chat SDK Slack adapter: https://chat-sdk.dev/adapters/slack

.agents/skills/slack-development/references/chat-sdk-patterns.md

@@ -6,17 +6,19 @@ Implementation patterns for responsive Slack UX in Chat SDK based bots.
 
 ## Long-running interaction pattern
 
+Repository-specific policy:
+
 1. Start with immediate feedback:
 
-- call `thread.startTyping("Working...")` when appropriate
-- or post a short acknowledgement message when typing is insufficient
+- prefer assistant status as the primary in-flight progress surface
+- use `thread.startTyping(...)` only when the current surface genuinely supports it and it does not conflict with the repository delivery contract
 
-2. Stream final output:
+2. Keep visible reply text finalized:
 
-- use AI SDK streaming (`streamText` or equivalent)
-- pass `textStream` to `thread.post(textStream)` for incremental Slack updates
+- do not treat incremental `thread.post(textStream)` output as the default correctness path in this repository
+- deliver the visible Slack reply after planning, chunking, and formatting are finalized
 
-3. Emit progress transitions for multi-step/tool-heavy work:
+3. Emit progress transitions for multi-step/tool-heavy work through assistant status:
 
 - "searching sources"
 - "fetching details"
@@ -28,14 +30,14 @@ Implementation patterns for responsive Slack UX in Chat SDK based bots.
 
 1. Avoids "silent" multi-minute runs.
 2. Improves user trust during tool execution.
-3. Produces better perceived latency without sacrificing completeness.
+3. Keeps Slack-visible text aligned with the finalized reply contract.
 
 ## Slack adapter capabilities to use
 
-1. `thread.startTyping(...)` for typing/status feedback.
-2. Native stream support through `thread.post(asyncIterable)` on Slack.
-3. `thread.postEphemeral(user, message, { fallbackToDM })` for messages visible only to one user.
-4. Optional Assistants API status features when `assistant:write` and assistant events are configured.
+1. `thread.startTyping(...)` for typing/status feedback when the current surface and contract allow it.
+2. `thread.postEphemeral(user, message, { fallbackToDM })` for messages visible only to one user.
+3. Optional Assistants API status features when the current Slack status/title scopes and assistant events are configured. Slack's status scope rules have changed recently, so verify the current docs before assuming `assistant:write` is required.
+4. Native stream support through `thread.post(asyncIterable)` exists, but in this repository it is not the baseline delivery contract for Slack replies.
 
 ## Ephemeral messages
 
@@ -66,11 +68,13 @@ Note: Ephemeral messages are only available when you have a thread handle (e.g.
 
 1. Keep webhook processing asynchronous with `waitUntil` in the webhook route.
 2. Keep external search behavior aligned with AI Gateway-native tools.
-3. Prefer one streaming response per user turn over many separate short messages.
+3. Prefer one finalized response plan per user turn over many separate short messages.
 
 ## Sources
 
 - Chat SDK streaming guide: https://chat-sdk.dev/docs/streaming
 - Chat SDK Slack adapter guide: https://chat-sdk.dev/docs/adapters/slack
 - Hono webhook pattern in Chat SDK guide: https://chat-sdk.dev/docs/guides/slack-hono
+- Slack `assistant.threads.setStatus` docs: https://docs.slack.dev/reference/methods/assistant.threads.setStatus
+- Slack status scope update: https://docs.slack.dev/changelog/2026/03/05/set-status-scope-update/
 - AI Gateway web search capabilities: https://vercel.com/docs/ai-gateway/capabilities/web-search