@fastagent-sh/fastagent 0.15.0 → 0.16.0

package/dist/channels/feishu/setup-mode.d.ts

@@ -4,5 +4,34 @@ export type FeishuSubscriptionMode = "webhook" | "websocket";
  * runtime remains capability-driven because the platform, not channel source, decides which events
  * are delivered. */
 export type FeishuGroupBehavior = "context" | "mentions";
-/** The sensitive tenant scope behind both managed-thread bare replies and group context buffering. */
+/** The sensitive tenant scope behind both bare replies in the agent's threads and group context buffering. */
 export declare const FEISHU_GROUP_CONTEXT_SCOPE = "im:message.group_msg";
+/** Reading a QUOTED message by id, so an ask carries what it replies to (participant-model.md §8).
+ *  INDEPENDENT of the delivery scope above and of the group posture: the read runs in every chat type
+ *  (a p2p thread's opening ask, any quoted @mention in a group). It is also a softer dependency —
+ *  without it everything still works, and an unreadable quote degrades to a marker in the prompt.
+ *  Bundled into the context-aware request only because that path already needs an approval round; a
+ *  mention-only app wanting referents must add it by hand. */
+export declare const FEISHU_MESSAGE_READ_SCOPE = "im:message:readonly";
+/** A scope the onboarding asks for, plus any BROADER spelling that already satisfies it. One concept,
+ *  so adding a superset means editing the entry — not every call site that tests a scope. */
+export interface FeishuScopeRequest {
+    /** What to add to the app draft when nothing satisfies it. Always counts as satisfying itself. */
+    request: string;
+    /** EXTRA spellings that also count — supersets. Optional; `request` is implicit. Modelled this way
+     *  so a request that can never be satisfied (a list omitting its own `request`) cannot be
+     *  written: onboarding would add the scope, the tenant would grant it, and it would still read as
+     *  missing forever. */
+    supersets?: string[];
+}
+/** Whether `predicate` holds for any spelling that satisfies this request. */
+export declare function scopeSatisfied(entry: FeishuScopeRequest, predicate: (name: string) => boolean): boolean;
+/** Reading a quoted message: `im:message` is the read/write superset, so an app holding it can already
+ *  do so — checking only the readonly spelling would warn a correctly configured app forever and push
+ *  its author into a redundant approval round. Exported on its own because the serving-time capability
+ *  report asks the same question, and a second mechanism there is what this type exists to prevent. */
+export declare const FEISHU_MESSAGE_READ_REQUEST: FeishuScopeRequest;
+/** What `--group-behavior context` REQUESTS in one approval round — not a dependency set. Only the
+ *  delivery scope is required for the context path; the read scope rides along because it shares the
+ *  round and its absence merely degrades quoted messages to a marker. */
+export declare const FEISHU_CONTEXT_ONBOARDING_SCOPES: FeishuScopeRequest[];

package/dist/channels/feishu/setup-mode.js

@@ -1,2 +1,28 @@
-/** The sensitive tenant scope behind both managed-thread bare replies and group context buffering. */
+/** The sensitive tenant scope behind both bare replies in the agent's threads and group context buffering. */
 export const FEISHU_GROUP_CONTEXT_SCOPE = "im:message.group_msg";
+/** Reading a QUOTED message by id, so an ask carries what it replies to (participant-model.md §8).
+ *  INDEPENDENT of the delivery scope above and of the group posture: the read runs in every chat type
+ *  (a p2p thread's opening ask, any quoted @mention in a group). It is also a softer dependency —
+ *  without it everything still works, and an unreadable quote degrades to a marker in the prompt.
+ *  Bundled into the context-aware request only because that path already needs an approval round; a
+ *  mention-only app wanting referents must add it by hand. */
+export const FEISHU_MESSAGE_READ_SCOPE = "im:message:readonly";
+/** Whether `predicate` holds for any spelling that satisfies this request. */
+export function scopeSatisfied(entry, predicate) {
+    return [entry.request, ...(entry.supersets ?? [])].some(predicate);
+}
+/** Reading a quoted message: `im:message` is the read/write superset, so an app holding it can already
+ *  do so — checking only the readonly spelling would warn a correctly configured app forever and push
+ *  its author into a redundant approval round. Exported on its own because the serving-time capability
+ *  report asks the same question, and a second mechanism there is what this type exists to prevent. */
+export const FEISHU_MESSAGE_READ_REQUEST = {
+    request: FEISHU_MESSAGE_READ_SCOPE,
+    supersets: ["im:message"],
+};
+/** What `--group-behavior context` REQUESTS in one approval round — not a dependency set. Only the
+ *  delivery scope is required for the context path; the read scope rides along because it shares the
+ *  round and its absence merely degrades quoted messages to a marker. */
+export const FEISHU_CONTEXT_ONBOARDING_SCOPES = [
+    { request: FEISHU_GROUP_CONTEXT_SCOPE },
+    FEISHU_MESSAGE_READ_REQUEST,
+];

package/dist/channels/github/github.js

@@ -7,6 +7,7 @@ import { verify } from "@octokit/webhooks-methods";
 import { collect } from "../../collect.js";
 import { log } from "../../log.js";
 import { readBodyCapped } from "../body.js";
+import { beginWork } from "../busy.js";
 import { text } from "../respond.js";
 /** Raw body cap before verification — GitHub caps webhook payloads at 25 MB; reject larger early. */
 const MAX_WEBHOOK_BYTES = 25 << 20;
@@ -67,7 +68,13 @@ export function githubChannel({ secret, on }) {
                 const turn = `${event.deliveryId}#${i}`;
                 log.info(`[github] turn start: turn=${turn} session=${session} event=${label}`);
                 const startedAt = Date.now();
-                void collect(agent.invoke({ session }, { text })).then(() => log.info(`[github] turn done: turn=${turn} session=${session} (${Date.now() - startedAt}ms)`), (error) => log.error(`[github] turn failed: turn=${turn} session=${session} (${Date.now() - startedAt}ms): ${String(error)}`));
+                // Post-ACK turns are process-wide in-flight work (busy.ts): a serving surface that must not
+                // idle mid-turn (the AgentCore /ping's HealthyBusy) has no other way to see them — and github
+                // turns have NO replay, so an idle reclaim here loses the review outright.
+                const workDone = beginWork();
+                void collect(agent.invoke({ session }, { text }))
+                    .then(() => log.info(`[github] turn done: turn=${turn} session=${session} (${Date.now() - startedAt}ms)`), (error) => log.error(`[github] turn failed: turn=${turn} session=${session} (${Date.now() - startedAt}ms): ${String(error)}`))
+                    .finally(workDone);
             }
             return new Response(null, { status: 202 });
         },

package/dist/channels/http.js

@@ -6,7 +6,7 @@
  * web stream primitives give cancellation (consumer disconnect → cancel() → iterator.return() →
  * invoke cancellation, SPEC MUST 3), backpressure (pull-based), and the body cap natively.
  *
- * `nodeListener` is the thin node:http adapter for the standalone `fastagent dev/start` server.
+ * `nodeListener` is the thin node:http adapter for the embedded `fastagent dev/start` server.
  */
 import { Readable } from "node:stream";
 import { log } from "../log.js";

package/dist/channels/lark/scaffold/channel.ts

@@ -8,8 +8,10 @@ import { larkChannel } from "@fastagent-sh/fastagent/lark";
 //   2. Permissions: add `im:message.p2p_msg:readonly` (direct messages), `im:message.group_at_msg:readonly`
 //      (group @mentions), `im:message:send_as_bot` (reply), `im:resource` (attachments), and the
 //      card scope ("Create and update card" — the live preview streams through a card). To answer bare
-//      messages in Agent-managed threads and buffer other unsummoned group/thread context, also add the
-//      sensitive `im:message.group_msg` scope (tenant-admin approval) and publish a new version.
+//      messages in threads the Agent takes part in, and buffer other unsummoned group/thread context, also add the
+//      sensitive `im:message.group_msg` scope (tenant-admin approval) and publish a new version. Add a
+//      message-read scope (e.g. `im:message:readonly`) too, so a thread's opening ask can carry the
+//      message it quotes; without it that quote degrades to a marker in the prompt.
 //   3. Events & Callbacks → subscribe to `im.message.receive_v1`; copy the Verification Token into
 //      .env; RECOMMENDED: set an Encrypt Key there and mirror it in LARK_ENCRYPT_KEY
 //   4. run `fastagent dev --tunnel`: it attempts to switch Subscription mode to webhook + register
@@ -21,18 +23,17 @@ export default larkChannel({
   appSecret: process.env.LARK_APP_SECRET ?? "",
   verificationToken: process.env.LARK_VERIFICATION_TOKEN ?? "", // authenticates inbound events
   encryptKey: process.env.LARK_ENCRYPT_KEY || undefined, // optional; when set, plaintext events are refused
-  // Direct and group chats default to one Agent session/thread per top-level ask. Opt out independently:
-  // directMessageSession: "continuous",
-  // groupMessageSession: "continuous",
+  // No session modes: a chat is one session and a thread is another, and where the answer goes follows
+  // from that (docs/design/participant-model.md).
   // Dev/personal bot: surface raw errors to the chat so you (and your AI agent) can act on them. The
   // chat is customer-facing by default — for a public bot, drop this or return a neutral string;
   // full details always go to the server log regardless.
   onError: (failed) => `⚠️ ${failed.details}`,
   // The channel owns transport + format (markdown card) + attachments (image→vision, file→disk) +
   // the live streaming preview. `route` (POLICY) is OPTIONAL — omitted, it uses defaultLarkRoute:
-  // p2p chats always answer; groups answer on @this-bot, plus bare continuations in Agent-managed
-  // threads. Other human group/thread discussion buffers until that place's next answered turn;
-  // @other-only messages in managed threads buffer rather than triggering the Agent.
+  // p2p chats always answer; groups answer on @this-bot, plus bare messages in a thread where the
+  // Agent takes part and exactly ONE human does. Other human group/thread discussion buffers until
+  // that place's next answered turn; @other-only messages buffer rather than triggering the Agent.
   // Override to customise explicit routing, reusing the export:
   //   route: (e) => defaultLarkRoute(e, { botOpenId: "ou_xxx" }) && { session: `user:${e.sender?.sender_id?.open_id}` },
   //   route: (e) => defaultLarkRoute(e, { botOpenId: "ou_xxx" }) && { text: `${larkEnvelope(e)}\n[extra]` },

package/dist/channels/lark/scaffold/lark-send.ts

@@ -6,7 +6,7 @@ import { defineTool, z } from "@fastagent-sh/fastagent";
 // context line in a chat turn; a scheduled turn has no such line, so the schedule's prompt must name
 // the target chat id. tools/ is auto-discovered.
 
-// Standalone copy of the channel transport's discipline: a timeout so a wedged connection can't hang
+// Embedded copy of the channel transport's discipline: a timeout so a wedged connection can't hang
 // the tool call (and the turn), named errors, and success gated on the body's own code===0.
 // Deliberately NO rate-limit retry — a tool error goes back to the agent, which can decide to retry;
 // fail-fast beats a silently sleeping tool.
@@ -57,9 +57,11 @@ async function tenantToken(): Promise<string> {
 export default defineTool({
   description:
     "Send a message to a Lark chat: plain `text`, or `markdown` (rendered as a card — headings, " +
-    "bold, code blocks, links). Exactly one of the two. In a chat turn take chatId from the " +
-    "[lark: chat …] context line; in a scheduled/woken turn (no context line) the chat id must come " +
-    "from your instruction.",
+    "bold, code blocks, links). Exactly one of the two. Use it for a turn NO channel is carrying — a " +
+    "scheduled or self-scheduled (wake) turn — or to reach a chat OTHER than the one you are " +
+    "answering. In a normal chat turn the channel already delivers your reply, so do NOT call this to " +
+    "answer (it would post the message twice). chatId comes from the [lark: chat …] context line in a " +
+    "chat turn; a scheduled/woken turn has no context line, so name the destination in your instruction.",
   input: z.object({
     chatId: z.string().describe("target chat id (oc_…)"),
     text: z.string().optional().describe("plain text message to send"),

package/dist/channels/preview-kit.d.ts

@@ -8,7 +8,7 @@
  * everything platform-independent lives here, so a new event type or a wording change lands in ONE
  * place instead of one hunk per channel.
  */
-import type { AgentEvent } from "../agent.ts";
+import type { AgentEvent, Json } from "../agent.ts";
 /** A terminal failure, as a channel hands it to its `onError`. */
 export interface ChannelFailure {
     details: string;
@@ -97,6 +97,12 @@ export declare function createPreviewPump(opts: {
      *  must be diagnosable, not silent — and not a log flood. */
     onError: (error: unknown) => void;
 }): PreviewPump;
+/**
+ * A compact, human-readable preview of a tool call's args so the live view reads `🔧 read AGENTS.md`
+ * rather than just `🔧 read`. Generic (a channel knows no tool schemas): show the salient value — the
+ * first primitive field, conventionally the subject (path / command / query / url) — else compact JSON.
+ */
+export declare function summarizeToolArgs(args: Json): string;
 /**
  * A plain-language label for a tool call, following Slack's agent-design guidance to name what a tool
  * does rather than expose a raw identifier ("Create issue", not "create_issue"; "Github: create issue",

package/dist/channels/preview-kit.js

@@ -138,7 +138,8 @@ export function createPreviewPump(opts) {
         },
     };
 }
-/** Max length (code points) of a tool's arg preview in the live view. */
+/** Max length (code points) of a tool's arg preview. Slack's native stream cannot be retracted, so
+ *  this is a disclosure bound, not only a layout one. */
 const TOOL_ARG_MAX = 48;
 /** Max length (code points) of a humanized tool label. */
 const TOOL_NAME_MAX = 80;
@@ -153,7 +154,7 @@ function clip(s) {
  * rather than just `🔧 read`. Generic (a channel knows no tool schemas): show the salient value — the
  * first primitive field, conventionally the subject (path / command / query / url) — else compact JSON.
  */
-function summarizeToolArgs(args) {
+export function summarizeToolArgs(args) {
     if (args === null || typeof args !== "object" || Array.isArray(args))
         return clip(String(args));
     const values = Object.values(args);

package/dist/channels/slack/parse.d.ts

@@ -1,5 +1,14 @@
 import type { SlackEventEnvelope, SlackMessageEvent, SlackRoute } from "./model.ts";
 export type { SlackEventEnvelope, SlackFile, SlackMessageEvent, SlackRoute } from "./model.ts";
+/** Does this text address ANYONE — a user, a broadcast, or a user group? The §3 discussion guard. */
+export declare function hasSlackMention(text: string): boolean;
+/** Does this text mention a USER? Distinct from the above because only a user mention can be the bot:
+ *  a broadcast never is, so it must not make a message look like a possible summon. */
+export declare function hasSlackUserMention(text: string): boolean;
+/** Does this text mention this specific user (either form)? The id is MATCHED, not interpreted. */
+export declare function mentionsSlackUser(text: string, userId: string): boolean;
+/** Strip every mention, e.g. before matching a bare command word or building a title. */
+export declare function stripSlackMentions(text: string, replacement?: string): string;
 /** Slack message events whose content represents a new human message rather than a mutation/service event. */
 export declare function isSlackHumanMessage(event: SlackMessageEvent | undefined): event is SlackMessageEvent & {
     channel: string;
@@ -14,7 +23,13 @@ export declare function slackFileIds(event: SlackMessageEvent): string[];
 /** Text plus a structural marker for file-only or captioned file shares. */
 export declare function slackMessageText(event: SlackMessageEvent): string;
 export declare function slackSenderLabel(event: SlackMessageEvent): string;
-/** Main-channel discussion and each concrete thread are independent context buckets. */
+/** Main-channel discussion and each concrete thread are independent context buckets.
+ *
+ *  The `:root:` segment carries `thread_ts`, which in Slack IS the thread's parent message and is
+ *  stable for the life of the thread — unrelated to the `<chat>:root:<root_id>` shape Feishu retired
+ *  (its `root_id` moves with the reply chain, so it could not identify a side conversation at all).
+ *  Same token, different platform meaning; the key is left as-is because renaming it would discard
+ *  live context buckets for no semantic gain. */
 export declare function slackPlaceKey(teamId: string, event: Pick<SlackMessageEvent, "channel" | "thread_ts">): string;
 export declare function slackBufferText(text: string): string;
 /** Canonical prompt envelope. The channel/thread ids also give slack-send an explicit delivery target. */

package/dist/channels/slack/parse.js

@@ -1,5 +1,42 @@
-import { codePointPrefix } from "../text.js";
+import { BUFFER_LINE_MAX_CHARS } from "../context-buffer.js";
+import { codePointPrefix, truncateCodePointPrefix } from "../text.js";
 const HUMAN_MESSAGE_SUBTYPES = new Set(["file_share", "thread_broadcast"]);
+/**
+ * Both forms Slack writes a mention in: `<@U123>` and the labelled `<@U123|name>`. ONE definition,
+ * because the forms have to agree across every site that reads them — the "@-mentions only other
+ * people is discussion" guard, the structural bot-summon check, the stop-command strip, and the
+ * assistant-thread title. They drifted once: widening the first two while the strip still matched only
+ * the bare form turned `<@bot|name> stop` into an ordinary turn, queued behind the run it meant to stop.
+ */
+const mentionSource = (idPattern) => String.raw `<@${idPattern}(?:\|[^>]*)?>`;
+const USER_MENTION = mentionSource("[A-Z0-9]+");
+/** Broadcasts and user groups address people too: `<!here>`, `<!channel>`, `<!everyone>`,
+ *  `<!subteam^S123|@team>`. Feishu's twin guard counts every mention, and the summon rule is supposed
+ *  to be the same on both — without these, "@here can someone look at this" in a thread the agent takes
+ *  part in reads as a bare message addressed to IT, and gets answered. */
+const ANY_MENTION = String.raw `(?:${USER_MENTION}|<!(?:here|channel|everyone)(?:\|[^>]*)?>|<!subteam\^[^>]*>)`;
+/** Does this text address ANYONE — a user, a broadcast, or a user group? The §3 discussion guard. */
+export function hasSlackMention(text) {
+    return new RegExp(ANY_MENTION, "i").test(text);
+}
+/** Does this text mention a USER? Distinct from the above because only a user mention can be the bot:
+ *  a broadcast never is, so it must not make a message look like a possible summon. */
+export function hasSlackUserMention(text) {
+    return new RegExp(USER_MENTION, "i").test(text);
+}
+/** Escape a platform-supplied id before it becomes part of a pattern. Slack ids are alphanumeric in
+ *  practice, but `auth.test`'s value is not validated here, and this runs on every group message: an
+ *  unescaped metacharacter would either mis-answer the summon question or throw on the acceptance
+ *  path, which Slack answers with an endless redelivery. */
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Does this text mention this specific user (either form)? The id is MATCHED, not interpreted. */
+export function mentionsSlackUser(text, userId) {
+    return new RegExp(mentionSource(escapeRegExp(userId)), "i").test(text);
+}
+/** Strip every mention, e.g. before matching a bare command word or building a title. */
+export function stripSlackMentions(text, replacement = " ") {
+    return text.replace(new RegExp(ANY_MENTION, "gi"), replacement);
+}
 /** Slack message events whose content represents a new human message rather than a mutation/service event. */
 export function isSlackHumanMessage(event) {
     if (!event || (event.type !== "message" && event.type !== "app_mention"))
@@ -38,13 +75,19 @@ export function slackMessageText(event) {
 export function slackSenderLabel(event) {
     return `user ${event.user ?? "unknown"}`;
 }
-/** Main-channel discussion and each concrete thread are independent context buckets. */
+/** Main-channel discussion and each concrete thread are independent context buckets.
+ *
+ *  The `:root:` segment carries `thread_ts`, which in Slack IS the thread's parent message and is
+ *  stable for the life of the thread — unrelated to the `<chat>:root:<root_id>` shape Feishu retired
+ *  (its `root_id` moves with the reply chain, so it could not identify a side conversation at all).
+ *  Same token, different platform meaning; the key is left as-is because renaming it would discard
+ *  live context buckets for no semantic gain. */
 export function slackPlaceKey(teamId, event) {
     const base = `${teamId}:${event.channel ?? "unknown-channel"}`;
     return event.thread_ts ? `${base}:root:${event.thread_ts}` : base;
 }
 export function slackBufferText(text) {
-    return codePointPrefix(text.replace(/\s+/g, " ").trim(), 280);
+    return truncateCodePointPrefix(text.replace(/\s+/g, " ").trim(), BUFFER_LINE_MAX_CHARS);
 }
 /** Canonical prompt envelope. The channel/thread ids also give slack-send an explicit delivery target. */
 export function slackEnvelope(envelope) {

package/dist/channels/slack/preview.d.ts

@@ -1,7 +1,7 @@
 /** Slack reply rendering: native Agent streams first, rate-safe edited-message compatibility second. */
 import type { AgentEvent } from "../../agent.ts";
 import { type ChannelFailure, defaultErrorMessage } from "../preview-kit.ts";
-import { type SlackApi, type SlackTarget, type SlackTaskDisplayMode } from "./slack-api.ts";
+import { type SlackApi, type SlackTarget } from "./slack-api.ts";
 export type SlackFailure = ChannelFailure;
 export type SlackRendering = "native" | "classic";
 export { defaultErrorMessage };
@@ -19,6 +19,5 @@ export declare function streamSlackReply(events: AsyncIterable<AgentEvent>, api:
     initialPreviewTs?: string;
     threadTitle?: string;
     disclaimer?: string | false;
-    taskDisplay?: SlackTaskDisplayMode;
     label?: string;
 }): Promise<void>;

package/dist/channels/slack/preview.js

@@ -1,5 +1,5 @@
 import { log } from "../../log.js";
-import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, toolLines, } from "../preview-kit.js";
+import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../preview-kit.js";
 import { chunkSlackMarkdown, chunkSlackText, isSlackNativeUnavailable, } from "./slack-api.js";
 export { defaultErrorMessage };
 const CLASSIC_UPDATE_INTERVAL_MS = 3_000;
@@ -16,6 +16,39 @@ const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export function sanitizeSlackMarkdown(markdown) {
     return markdown.replace(/<[@!][^<>]*>/g, (control) => `&lt;${control.slice(1)}`);
 }
+/** Render untrusted tool names/arguments as one standard-Markdown code span. A fence longer than any
+ * backtick run in the value keeps the span balanced without changing the factual text. */
+function inlineCode(value) {
+    const longest = Math.max(0, ...(value.match(/`+/g) ?? []).map((run) => run.length));
+    const fence = "`".repeat(longest + 1);
+    const content = value.startsWith("`") || value.endsWith("`") ? ` ${value} ` : value;
+    return `${fence}${content}${fence}`;
+}
+function nativeToolTrace(name, args) {
+    const operation = sanitizeSlackMarkdown(summarizeToolArgs(args));
+    return {
+        label: sanitizeSlackMarkdown(humanizeToolName(name)),
+        ...(operation ? { operation } : {}),
+    };
+}
+/** Bold a factual label. `humanizeToolName` normalizes `_` away for every ordinary identifier, but it
+ * falls back to the raw name when normalization empties it (a tool literally named `_`), so emphasis
+ * characters are escaped rather than assumed absent. */
+function boldText(value) {
+    return `**${value.replace(/[\\*_]/g, "\\$&")}**`;
+}
+/**
+ * One trace line: the tool, what it was called on, and — on the failure line — that it failed.
+ *
+ * Tool OUTPUT never leaves the process, failed or not: the channel would have to guess the engine's
+ * result shape to read it, and the agent already explains a failure it recovered from in its answer.
+ * The failure line therefore repeats the operation instead of adding one: it states WHICH call failed
+ * (six `Bash` calls in a turn are otherwise indistinguishable) without exposing anything the start
+ * line did not already show. Operators get the detail from the logs.
+ */
+function nativeToolLine(trace, outcome = "") {
+    return `${boldText(trace.label)}${outcome}${trace.operation ? ` — ${inlineCode(trace.operation)}` : ""}`;
+}
 function withDisclaimer(markdown, disclaimer) {
     const body = markdown.trim() || "(no reply)";
     return disclaimer === false || !disclaimer?.trim() ? body : `${body}\n\n_${disclaimer.trim()}_`;
@@ -163,7 +196,7 @@ async function streamClassicSlackReply(events, api, target, formatError, initial
         }
     }
 }
-async function streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label, taskDisplayMode) {
+async function streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label) {
     if (initialPreviewTs) {
         await api
             .deleteMessage(target.channelId, initialPreviewTs)
@@ -192,7 +225,7 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
             .setThreadStatus(target, status)
             .catch((error) => log.warn(`${label} could not set Slack Agent status: ${String(error)}`)));
     };
-    const toolNames = new Map();
+    const toolTraces = new Map();
     let pendingText = "";
     let fullAnswer = "";
     let textTimer;
@@ -200,6 +233,8 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
     let operation = Promise.resolve();
     let renderError;
     let finalized = false;
+    let streamHasContent = false;
+    let streamEndsWithBlankLine = false;
     const enqueue = (work) => {
         operation = operation.then(async () => {
             if (renderError !== undefined)
@@ -212,14 +247,21 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
             }
         });
     };
-    const sendContent = async (content) => {
+    const sendContent = async (markdown) => {
         if (streamTs) {
-            await api.appendStream(target.channelId, streamTs, content);
+            await api.appendStream(target.channelId, streamTs, markdown);
         }
         else {
-            streamTs = await api.startStream(target, content, taskDisplayMode);
+            streamTs = await api.startStream(target, markdown);
         }
     };
+    const queueMarkdown = (markdown) => {
+        if (!markdown)
+            return;
+        streamHasContent = true;
+        streamEndsWithBlankLine = markdown.endsWith("\n\n");
+        enqueue(() => sendContent(markdown));
+    };
     const flushText = (final = false) => {
         if (textTimer) {
             clearTimeout(textTimer);
@@ -239,9 +281,8 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
         if (!value)
             return;
         lastTextFlushAt = Date.now();
-        for (const chunk of chunkSlackText(sanitizeSlackMarkdown(value))) {
-            enqueue(() => sendContent({ markdownText: chunk }));
-        }
+        for (const chunk of chunkSlackText(sanitizeSlackMarkdown(value)))
+            queueMarkdown(chunk);
     };
     const scheduleText = () => {
         if (textTimer)
@@ -252,9 +293,14 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
             flushText();
         }, delay);
     };
-    const sendTask = (chunk) => {
+    // ponytail: a trace appended while the answer has an unclosed ``` fence lands inside it, and the
+    // trace's own backticks can close it early. Tracking fence parity across chunk boundaries (the job
+    // chunkSlackMarkdown does for the classic renderer) is the fix if a model is ever seen calling a
+    // tool mid-fence; the trace's blank-line framing keeps every other case well-formed.
+    const sendToolTrace = (line) => {
         flushText();
-        enqueue(() => sendContent({ chunks: [chunk] }));
+        const separator = streamHasContent && !streamEndsWithBlankLine ? "\n\n" : "";
+        queueMarkdown(`${separator}${line}\n\n`);
     };
     const settleNative = async (terminalMarkdown) => {
         flushText(true);
@@ -267,12 +313,12 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
                 return;
             }
             if (streamTs) {
-                await api.stopStream(target.channelId, streamTs, { markdownText: `\n\n${GENERIC_FAILURE}` }).catch(() => { });
+                await api.stopStream(target.channelId, streamTs, `\n\n${GENERIC_FAILURE}`).catch(() => { });
             }
             throw renderError;
         }
         if (!streamTs)
-            streamTs = await api.startStream(target, { markdownText: safeTerminal }, taskDisplayMode);
+            streamTs = await api.startStream(target, safeTerminal);
         await api.stopStream(target.channelId, streamTs);
     };
     try {
@@ -300,17 +346,15 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
                 }
             }
             else if (event.type === "tool_started") {
-                const title = humanizeToolName(event.name);
-                toolNames.set(event.id, title);
-                sendTask({ type: "task_update", id: event.id, title, status: "in_progress" });
+                const trace = nativeToolTrace(event.name, event.args);
+                toolTraces.set(event.id, trace);
+                sendToolTrace(nativeToolLine(trace));
             }
             else if (event.type === "tool_ended") {
-                sendTask({
-                    type: "task_update",
-                    id: event.id,
-                    title: toolNames.get(event.id) ?? "Tool",
-                    status: event.isError ? "error" : "complete",
-                });
+                const trace = toolTraces.get(event.id) ?? { label: "Tool" };
+                toolTraces.delete(event.id);
+                if (event.isError)
+                    sendToolTrace(nativeToolLine(trace, " failed"));
             }
             else if (event.type === "completed") {
                 finalized = true;
@@ -348,9 +392,9 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
     }
 }
 export async function streamSlackReply(events, api, target, formatError, options = {}) {
-    const { rendering = "native", initialPreviewTs, threadTitle, disclaimer, taskDisplay = "plan", label = "[slack]", } = options;
+    const { rendering = "native", initialPreviewTs, threadTitle, disclaimer, label = "[slack]" } = options;
     if (rendering === "native" && target.threadTs) {
-        return streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label, taskDisplay);
+        return streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label);
     }
     if (rendering === "native") {
         log.info(`${label} native streaming needs a thread target — using the classic renderer for this turn`);

package/dist/channels/slack/scaffold/channel.ts

@@ -20,14 +20,14 @@ export default slackChannel({
     ? Number(process.env.SLACK_BOT_TOKEN_EXPIRES_AT)
     : undefined,
   groupBehavior: "context", // default; use "mentions" only for an explicit least-privilege setup
-  rendering: "native", // Slack Agent streams + task timeline; use "classic" only for compatibility
-  // taskDisplay: "plan", // native task-card layout: "plan" (default) | "timeline" | "dense"
+  // Slack Agent stream; its inline tool traces show each call's first argument and stay in the
+  // delivered message. "classic" settles into the answer alone (and gives up native streaming).
+  rendering: "native",
   // Optional per-reply footer, if your policy requires one: aiDisclaimer: "AI-generated; verify important information.",
   // welcome: "Custom first-run DM greeting", // sent once on first DM open; false disables (default: a generic greeting)
   // reactionAck: false, // disable the 👀→✅ ack on the user's message (default on; needs reactions:write)
-  // Direct and group asks default to independent sessions + Slack threads; opt out independently:
-  // directMessageSession: "continuous",
-  // groupMessageSession: "continuous",
+  // No session modes: an answer attaches to its question with a thread (Slack has no quote primitive),
+  // and that thread is the session — see docs/design/participant-model.md.
   // Dev/personal bot: surface raw errors. Remove this for a customer-facing bot; details remain in logs.
   onError: (failed) => `⚠️ ${failed.details}`,
 });

package/dist/channels/slack/slack-api.d.ts

@@ -7,25 +7,6 @@ export interface SlackTarget {
     recipientUserId?: string;
     recipientTeamId?: string;
 }
-interface SlackMarkdownTextChunk {
-    type: "markdown_text";
-    text: string;
-}
-interface SlackTaskUpdateChunk {
-    type: "task_update";
-    id: string;
-    title: string;
-    status: "pending" | "in_progress" | "complete" | "error";
-}
-export type SlackStreamChunk = SlackMarkdownTextChunk | SlackTaskUpdateChunk;
-interface SlackStreamContent {
-    markdownText?: string;
-    chunks?: SlackStreamChunk[];
-}
-/** How Slack lays out task cards in a native stream (chat.startStream `task_display_mode`): `timeline`
- *  lists steps sequentially, `plan` groups them under one heading, `dense` collapses consecutive tool
- *  calls into one summarized card. */
-export type SlackTaskDisplayMode = "timeline" | "plan" | "dense";
 export interface DownloadedSlackFile {
     path: string;
     name: string;
@@ -58,9 +39,9 @@ export interface SlackApi {
     updateMarkdown(channelId: string, ts: string, markdown: string): Promise<void>;
     deleteMessage(channelId: string, ts: string): Promise<void>;
     sendMarkdown(target: SlackTarget, markdown: string): Promise<string | undefined>;
-    startStream(target: SlackTarget, content?: SlackStreamContent, taskDisplayMode?: SlackTaskDisplayMode): Promise<string>;
-    appendStream(channelId: string, ts: string, content: SlackStreamContent): Promise<void>;
-    stopStream(channelId: string, ts: string, content?: SlackStreamContent): Promise<void>;
+    startStream(target: SlackTarget, markdown?: string): Promise<string>;
+    appendStream(channelId: string, ts: string, markdown: string): Promise<void>;
+    stopStream(channelId: string, ts: string, markdown?: string): Promise<void>;
     setThreadStatus(target: SlackTarget, status: string): Promise<void>;
     setThreadTitle(target: SlackTarget, title: string): Promise<void>;
     addReaction(channelId: string, timestamp: string, emoji: string): Promise<void>;
@@ -74,4 +55,3 @@ export declare function chunkSlackText(text: string, maxPoints?: number): string
 /** Split standard Markdown while balancing fenced code blocks across separately posted messages. */
 export declare function chunkSlackMarkdown(markdown: string, maxPoints?: number): string[];
 export declare function createSlackApi({ botToken, baseUrl }: SlackApiOptions): SlackApi;
-export {};

package/dist/channels/slack/slack-api.js

@@ -95,14 +95,6 @@ export function chunkSlackMarkdown(markdown, maxPoints = SLACK_MAX_MARKDOWN) {
     }
     return output;
 }
-/** Slack locks a stream to top-level `markdown_text` or `chunks` mode on its first write. Tasks need
- * chunks, so encode text as markdown chunks too; mixing the two modes yields `streaming_mode_mismatch`. */
-function streamChunks(content) {
-    return [
-        ...(content.markdownText ? [{ type: "markdown_text", text: content.markdownText }] : []),
-        ...(content.chunks ?? []),
-    ];
-}
 function safeFileName(file) {
     const raw = file.name ?? file.title ?? file.id ?? "file";
     const safe = raw.replace(/[/\\]/g, "_").replace(/^\.+/, "_") || "file";
@@ -310,7 +302,7 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
             }
             return first;
         },
-        async startStream(target, content = {}, taskDisplayMode = "plan") {
+        async startStream(target, markdown) {
             if (!target.threadTs)
                 throw new Error("Slack native streams require a parent thread timestamp");
             const channelRecipient = target.channelId.startsWith("D")
@@ -322,32 +314,24 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
             if (!target.channelId.startsWith("D") && (!target.recipientUserId || !target.recipientTeamId)) {
                 throw new Error("Slack native channel streams require recipient user and team IDs");
             }
-            const chunks = streamChunks(content);
             const data = await call("chat.startStream", {
                 channel: target.channelId,
                 thread_ts: target.threadTs,
-                task_display_mode: taskDisplayMode,
                 ...channelRecipient,
-                ...(chunks.length ? { chunks } : {}),
+                ...(markdown ? { markdown_text: markdown } : {}),
             });
             if (!data.ts)
                 throw new SlackApiError("chat.startStream", 200, "response carried no ts");
             return data.ts;
         },
-        async appendStream(channelId, ts, content) {
-            const chunks = streamChunks(content);
-            await call("chat.appendStream", {
-                channel: channelId,
-                ts,
-                ...(chunks.length ? { chunks } : {}),
-            });
+        async appendStream(channelId, ts, markdown) {
+            await call("chat.appendStream", { channel: channelId, ts, markdown_text: markdown });
         },
-        async stopStream(channelId, ts, content = {}) {
-            const chunks = streamChunks(content);
+        async stopStream(channelId, ts, markdown) {
             await call("chat.stopStream", {
                 channel: channelId,
                 ts,
-                ...(chunks.length ? { chunks } : {}),
+                ...(markdown ? { markdown_text: markdown } : {}),
             });
         },
         async setThreadStatus(target, status) {