@fastagent-sh/fastagent 0.24.4 → 0.26.0

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

@@ -1,7 +1,18 @@
+/**
+ * The ONE Slack transport per bot a process holds: the mounted channel's, shared with the scaffolded send tool, found
+ * by the bot token both hold.
+ */
+import { roomThreads } from "../kit/room-threads.ts";
 import { type SlackApi } from "./slack-api.ts";
 /** What a proactive sender needs: Markdown delivery and file upload. */
 export type SlackTransport = Pick<SlackApi, "sendMarkdown" | "uploadFile">;
-/** A re-mount replaces the entry: the channel's transport is the authoritative one for its root. */
-export declare function registerSlackApi(stateRoot: string, api: SlackApi): void;
-/** The transport of the agent whose workspace is `cwd` (a tool's `ctx.cwd`). */
-export declare function slackTransport(cwd: string): SlackTransport;
+/** A re-mount replaces the entry: the channel's transport is the authoritative one for its bot. */
+export declare function registerSlackApi(botToken: string, api: SlackApi): void;
+/** The transport of the bot `botToken` signs in as: its mounted channel's, or the token's own when none is mounted. */
+export declare function slackTransport(botToken: string): SlackTransport;
+/**
+ * The threads of the channel the message running in `sessionId` was asked in, and only those (`kit/room-threads.ts`):
+ * `list()` its recent threads, `read(threadTs)` one of them. Throws outside a Slack channel turn served by this
+ * process.
+ */
+export declare function slackThreads(sessionId: string | undefined): ReturnType<typeof roomThreads>;

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

@@ -1,23 +1,28 @@
 /**
- * The ONE Slack transport per state root a process holds: the mounted channel's, shared with the scaffolded send tool.
+ * The ONE Slack transport per bot a process holds: the mounted channel's, shared with the scaffolded send tool, found
+ * by the bot token both hold.
  */
-import { resolvePlacement, resolveStateRoot } from "../../paths.js";
+import { roomThreads } from "../kit/room-threads.js";
 import { createSlackApi } from "./slack-api.js";
-const byStateRoot = new Map();
-/** A re-mount replaces the entry: the channel's transport is the authoritative one for its root. */
-export function registerSlackApi(stateRoot, api) {
-    byStateRoot.set(stateRoot, api);
+const byToken = new Map();
+/** A re-mount replaces the entry: the channel's transport is the authoritative one for its bot. */
+export function registerSlackApi(botToken, api) {
+    byToken.set(botToken, api);
 }
-/** The transport of the agent whose workspace is `cwd` (a tool's `ctx.cwd`). */
-export function slackTransport(cwd) {
-    const stateRoot = resolveStateRoot(resolvePlacement(cwd).agentDir);
-    let api = byStateRoot.get(stateRoot);
+/** The transport of the bot `botToken` signs in as: its mounted channel's, or the token's own when none is mounted. */
+export function slackTransport(botToken) {
+    let api = byToken.get(botToken);
     if (!api) {
-        const botToken = process.env.SLACK_BOT_TOKEN;
-        if (!botToken)
-            throw new Error("SLACK_BOT_TOKEN is not set and no Slack channel is mounted");
         api = createSlackApi({ botToken });
-        byStateRoot.set(stateRoot, api);
+        byToken.set(botToken, api);
     }
     return api;
 }
+/**
+ * The threads of the channel the message running in `sessionId` was asked in, and only those (`kit/room-threads.ts`):
+ * `list()` its recent threads, `read(threadTs)` one of them. Throws outside a Slack channel turn served by this
+ * process.
+ */
+export function slackThreads(sessionId) {
+    return roomThreads("slack", sessionId);
+}

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

@@ -1,4 +1,4 @@
-import type { ImageRef } from "../../agent.ts";
+import type { ImageAttachment as ImageRef } from "../kit/invoke-turn-kit.ts";
 import type { CallOptions } from "../kit/transport.ts";
 import type { SlackFile } from "./model.ts";
 export interface SlackTarget {
@@ -38,7 +38,65 @@ export interface SlackApiOptions {
     botToken: string;
     baseUrl?: string;
 }
+/** A message as `conversations.history` / `conversations.replies` list it: the fields a place's history reads. */
+export interface SlackListedMessage {
+    type?: string;
+    subtype?: string;
+    hidden?: boolean;
+    ts?: string;
+    thread_ts?: string;
+    /** On a thread's root, in a channel listing. */
+    reply_count?: number;
+    latest_reply?: string;
+    user?: string;
+    bot_id?: string;
+    username?: string;
+    bot_profile?: {
+        name?: string;
+    };
+    text?: string;
+    blocks?: unknown[];
+    /** Legacy attachments: where many integrations (CI, alerts) put all they say, with an empty `text`. */
+    attachments?: {
+        fallback?: string;
+        pretext?: string;
+        title?: string;
+        text?: string;
+    }[];
+    files?: SlackFile[];
+}
+/**
+ * The newest `limit` messages before `latest` (exclusive). There is deliberately no `oldest`: with it, both reads
+ * return the OLDEST `limit` after it instead, and `conversations.replies` then pages on to nothing (measured), so a
+ * reader cuts at its own cursor.
+ */
+interface SlackRange {
+    latest?: string;
+    limit: number;
+}
+/** Where a posted message landed: a channel's top level, or a thread in it. */
+type OnSent = (where: {
+    channelId: string;
+    threadTs?: string;
+}, ts: string) => void;
 export interface SlackApi {
+    /**
+     * The same transport, reporting every message it posts (`chat.postMessage`, every chunk of a long body, and
+     * `chat.startStream`) with where it landed. Edits, deletions and file uploads are not reported.
+     */
+    recordingSends(onSent: OnSent): SlackApi;
+    /** A channel's top-level messages in `range`, NEWEST first (`conversations.history`). */
+    channelHistory(channelId: string, range: SlackRange, opts?: CallOptions): Promise<{
+        messages: SlackListedMessage[];
+        hasMore: boolean;
+    }>;
+    /** A thread's replies in `range`, OLDEST first, after its root, which Slack lists whatever the range. */
+    threadReplies(channelId: string, threadTs: string, range: SlackRange, opts?: CallOptions): Promise<{
+        messages: SlackListedMessage[];
+        hasMore: boolean;
+    }>;
+    /** A person's name as the workspace shows it (`users.info`, needs `users:read`); undefined when it has none. */
+    userName(userId: string, opts?: CallOptions): Promise<string | undefined>;
     authTest(): Promise<{
         teamId?: string;
         userId?: string;
@@ -73,4 +131,5 @@ export interface SlackApi {
 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 declare function createSlackApi(options: SlackApiOptions): SlackApi;
+export {};

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

@@ -143,8 +143,12 @@ function assertLongLivedBotToken(botToken) {
             'create a new app (docs/slack.md → "If token rotation is on")');
     }
 }
-export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" }) {
-    assertLongLivedBotToken(botToken);
+export function createSlackApi(options) {
+    assertLongLivedBotToken(options.botToken);
+    return slackClient(options, undefined);
+}
+/** A transport holds no state between calls, so a recording one is simply another instance. */
+function slackClient({ botToken, baseUrl = "https://slack.com/api" }, onSent) {
     const apiBase = baseUrl.replace(/\/$/, "");
     const call = async (method, body, httpMethod = "POST", opts = {}) => {
         const retries = opts.retries ?? RETRIES;
@@ -220,6 +224,10 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
         }
         return { bytes: await readBytesCapped(response), contentType: response.headers.get("content-type") ?? undefined };
     };
+    const sent = (channelId, threadTs, ts) => {
+        onSent?.({ channelId, ...(threadTs ? { threadTs } : {}) }, ts);
+        return ts;
+    };
     const postMarkdown = async (target, markdown) => {
         const data = await call("chat.postMessage", {
             channel: target.channelId,
@@ -231,9 +239,24 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
         if (!data.ts)
             throw new SlackApiError("chat.postMessage", 200, "response carried no ts");
         // The response's `channel` is what resolves a user-id target to its DM; a channel target echoes itself.
-        return { ts: data.ts, channelId: data.channel ?? target.channelId };
+        const channelId = data.channel ?? target.channelId;
+        return { ts: sent(channelId, target.threadTs, data.ts), channelId };
     };
     const api = {
+        recordingSends: (record) => slackClient({ botToken, baseUrl }, record),
+        async channelHistory(channelId, range, opts) {
+            const data = await call("conversations.history", { channel: channelId, ...range }, "GET", opts);
+            return { messages: data.messages ?? [], hasMore: data.has_more === true };
+        },
+        async threadReplies(channelId, threadTs, range, opts) {
+            const data = await call("conversations.replies", { channel: channelId, ts: threadTs, ...range }, "GET", opts);
+            return { messages: data.messages ?? [], hasMore: data.has_more === true };
+        },
+        async userName(userId, opts) {
+            const data = await call("users.info", { user: userId }, "GET", opts);
+            const user = data.user;
+            return user?.profile?.display_name || user?.profile?.real_name || user?.real_name || user?.name || undefined;
+        },
         async authTest() {
             const data = await call("auth.test", {});
             return { teamId: data.team_id, userId: data.user_id, botId: data.bot_id };
@@ -248,7 +271,7 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
             });
             if (!data.ts)
                 throw new SlackApiError("chat.postMessage", 200, "response carried no ts");
-            return data.ts;
+            return sent(data.channel ?? target.channelId, target.threadTs, data.ts);
         },
         async postMarkdown(target, markdown) {
             return (await postMarkdown(target, markdown)).ts;
@@ -305,7 +328,7 @@ export function createSlackApi({ botToken, baseUrl = "https://slack.com/api" })
             });
             if (!data.ts)
                 throw new SlackApiError("chat.startStream", 200, "response carried no ts");
-            return data.ts;
+            return sent(target.channelId, target.threadTs, data.ts);
         },
         async appendStream(channelId, ts, markdown) {
             await call("chat.appendStream", { channel: channelId, ts, markdown_text: markdown });

package/dist/channels/slack/slack.js

@@ -1,6 +1,6 @@
 /** First-party Slack HTTP Events API channel: signed ingress, durable turns/context, files, and edited previews. */
 import { createHmac } from "node:crypto";
-import { isAbsolute, join } from "node:path";
+import { join } from "node:path";
 import { log } from "../../log.js";
 import { readBodyCapped } from "../body.js";
 import { text } from "../respond.js";
@@ -13,15 +13,15 @@ import * as Exit from "effect/Exit";
 import { portJoin } from "../../effect-port.js";
 import { createTaskTracker } from "../kit/tasks.js";
 import { attachmentsDir } from "../kit/attachment-path.js";
-import { ensureStateHome } from "../kit/state.js";
 import { dispatchStop, isStopText } from "../kit/stop-command.js";
 import { codePointPrefix } from "../kit/text.js";
+import { createRoomThreads, registerRoomThreads } from "../kit/room-threads.js";
 import { createTurnRunner } from "../kit/turn-runner.js";
 import { createTurnStore } from "../kit/turn-store.js";
 import { discussionBlock } from "../kit/context-buffer.js";
-import { collectSlackBufferedFiles, createSlackContextBuffer } from "./context-buffer.js";
+import { collectFoldedFiles, createSlackPlaceHistory, slackHistoryKey, slackPlaceOf, } from "./history.js";
 import { slackTurnStream } from "./invoke-turn.js";
-import { defaultSlackRoute, isSlackDirectMessage, isSlackGroupMessage, hasSlackMention, hasSlackUserMention, isSlackHumanMessage, mentionsSlackUser, stripSlackMentions, slackBufferText, slackEnvelope, slackFileIds, slackMessageText, slackPlaceKey, slackSenderLabel, slackTeamId, } from "./parse.js";
+import { defaultSlackRoute, isSlackDirectMessage, isSlackGroupMessage, hasSlackMention, isSlackHumanMessage, mentionsSlackUser, stripSlackMentions, slackEnvelope, slackFileIds, slackMessageText, slackTeamId, } from "./parse.js";
 import { defaultErrorMessage, deliverSlackAnswer, settleSlackPreview, slackReply, } from "./preview.js";
 import { completeSlackReaction, resolveReactionEmojis, startSlackReaction } from "./reaction.js";
 import { registerSlackApi } from "./shared-api.js";
@@ -40,9 +40,10 @@ function isStoredSlackTurn(value) {
     const turn = value;
     return (typeof turn?.id === "string" &&
         typeof turn.seq === "number" &&
-        typeof turn.session === "string" &&
+        typeof turn.conversation === "string" &&
         typeof turn.baseText === "string" &&
-        typeof turn.bufferKey === "string" &&
+        (turn.historyKey === undefined || typeof turn.historyKey === "string") &&
+        typeof turn.group === "boolean" &&
         typeof turn.teamId === "string" &&
         typeof turn.channelId === "string" &&
         (turn.threadTs === undefined || typeof turn.threadTs === "string") &&
@@ -74,10 +75,12 @@ const AUTH_ACK_BUDGET_MS = 2_000;
 function createSlackAuthentication(api, label) {
     let teamId;
     let botUserId;
+    let botId;
     let state = "pending";
     const settled = api.authTest().then((identity) => {
         teamId = identity.teamId;
         botUserId = identity.userId;
+        botId = identity.botId;
         state = "ready";
         log.info(`${label} authenticated${identity.teamId ? ` for workspace ${identity.teamId}` : ""}`);
     }, (error) => {
@@ -91,6 +94,7 @@ function createSlackAuthentication(api, label) {
         settled,
         teamId: () => teamId,
         botUserId: () => botUserId,
+        botId: () => botId,
         ready: () => state !== "pending"
             ? settled
             : new Promise((resolve, reject) => {
@@ -114,37 +118,74 @@ export function slackChannel(options) {
         throw new Error("slackChannel welcome must be a string or false");
     }
     const reactionEmojis = resolveReactionEmojis(reactionAck);
-    return ({ agent, stateRoot, control }) => {
+    return ({ agent, sessionFor, recordedSession, stateDir: stateHome }) => {
         if (!botToken)
             throw new Error("slackChannel requires a non-empty botToken (Bot User OAuth Token)");
         if (!signingSecret)
             throw new Error("slackChannel requires a non-empty signingSecret (Basic Information → App Credentials)");
-        if (!isAbsolute(stateRoot))
-            throw new Error(`slackChannel requires an absolute ctx.stateRoot, got "${stateRoot}"`);
         const label = "[slack]";
         const formatError = onError ?? defaultErrorMessage;
-        const stateHome = join(stateRoot, "channels", "slack");
-        ensureStateHome(stateHome);
         const api = createSlackApi({ botToken, baseUrl: apiBaseUrl });
-        registerSlackApi(stateRoot, api); // the send tool delivers through this one (shared-api.ts)
+        registerSlackApi(botToken, api); // the send tool delivers through this one (shared-api.ts)
         const auth = createSlackAuthentication(api, label);
         // Side tasks (stop feedback, DM welcomes) run off the ACK path but drain in turnsIdle.
         const sideTasks = createTaskTracker(label);
         const seen = createSeenRing(join(stateHome, "seen.json"), label);
         const threadParticipants = createThreadParticipants(join(stateHome, "thread-participants.json"), label);
         /**
-         * A thread's participation is keyed by the SESSION it describes — "the agent answered here" is a claim about a
-         * memory, so the two must not be re-keyable independently.
+         * A thread's participation is keyed by the CONVERSATION it describes — "the agent answered here" is a claim about
+         * a memory, so the two must not be re-keyable independently.
          */
-        const threadKey = (teamId, channelId, threadTs) => `slack:${teamId}:${channelId}:${threadTs}`;
+        const threadKey = (teamId, channelId, threadTs) => `${teamId}:${channelId}:${threadTs}`;
         const welcomed = createWelcomedUsers(join(stateHome, "welcomed.json"), label);
-        const buffer = createSlackContextBuffer(join(stateHome, "buffers.json"), label);
+        // Every message this channel took as input (a turn, a /stop) is in `seen`. A history read also leaves these out,
+        // to shape the prompt only — what keeps a queued ask out of an earlier turn is the read's bound, not this ring.
+        const history = createSlackPlaceHistory({
+            api,
+            self: () => ({ userId: auth.botUserId(), botId: auth.botId() }),
+            label,
+            path: join(stateHome, "history.json"),
+            isTurnInput: (key, ts) => {
+                const place = slackPlaceOf(key);
+                return seen.has(`${place.teamId}:${place.channelId}:${ts}`);
+            },
+        });
+        // A group turn's room, for the thread-reading tool (`slackThreads`): the channel it was asked in, and its threads.
+        const rooms = createRoomThreads({
+            list: (room) => history.threads(room),
+            read: async (room, threadTs) => {
+                if (!/^\d+\.\d+$/.test(threadTs)) {
+                    throw new Error(`"${threadTs}" is not a Slack thread id: pass a thread's id from the list (like 1712345678.123456)`);
+                }
+                const { teamId, channelId } = slackPlaceOf(room);
+                const key = slackHistoryKey(teamId, { channelId, threadTs });
+                return (await history.snapshot(key)).text || `(thread ${threadTs} shows no messages)`;
+            },
+        });
+        registerRoomThreads("slack", stateHome, rooms);
+        /**
+         * The client a turn posts through: what it posts (answer, queue notice, stop feedback) is in the session already,
+         * so the place it LANDS in records it, and that place's next read leaves it out — an answer to a channel's
+         * top-level ask lands in the thread it opens. The send tool uses the plain client, so what the agent posts itself
+         * stays discussion. A routed turn has no place and reads no history.
+         */
+        const placeApi = (turn) => turn.historyKey === undefined
+            ? api
+            : api.recordingSends((where, ts) => history.recordOutput(slackHistoryKey(turn.teamId, where), ts));
         const store = createTurnStore(join(stateHome, "turns.json"), {
             label,
             isRecord: isStoredSlackTurn,
             order: (a, b) => a.seq - b.seq,
         });
         const decide = route ?? defaultSlackRoute;
+        /** A channel turn under the default routing reads its channel's threads; a DM has none to read. */
+        const enterRoom = (turn) => {
+            if (!turn.group || turn.historyKey === undefined)
+                return {};
+            const { teamId, channelId } = slackPlaceOf(turn.historyKey);
+            const room = slackHistoryKey(teamId, { channelId });
+            return { enter: (sessionId) => rooms.enter(sessionId, room) };
+        };
         const targetOf = (turn) => ({
             channelId: turn.channelId,
             threadTs: turn.threadTs,
@@ -155,16 +196,20 @@ export function slackChannel(options) {
             const target = targetOf(turn);
             if (turn.nativeQueueStatus)
                 void api.setThreadStatus(target, "").catch(() => { });
-            void settleSlackPreview(api, target, turn.previewTs, "⚠️ I couldn’t complete an earlier request — please ask again.").catch((error) => log.warn(`${label} could not notify a dropped turn: ${String(error)}`));
+            void settleSlackPreview(placeApi(turn), target, turn.previewTs, "⚠️ I couldn’t complete an earlier request — please ask again.").catch((error) => log.warn(`${label} could not notify a dropped turn: ${String(error)}`));
         };
         const runner = createTurnRunner({
             label,
             store,
-            buffer,
+            discussion: history,
             seen,
             toStored: ({ previewTs: _preview, nativeQueueStatus: _status, ...intent }) => ({ ...intent, attempts: 0 }),
             fromStored: ({ attempts: _attempts, ...intent }) => ({ ...intent }),
-            bufferKey: (turn) => turn.bufferKey,
+            // The read ends at the ask (`messageRefOf`: the ts of the message that asked).
+            discussionKey: (turn) => {
+                const ask = messageRefOf(turn.id);
+                return turn.historyKey === undefined || ask === undefined ? undefined : { key: turn.historyKey, until: ask.ts };
+            },
             where: (turn) => `channel=${turn.channelId}`,
             onQueuedBehind(turn) {
                 const nativeDmStatus = rendering === "native" && turn.threadTs && turn.channelId.startsWith("D");
@@ -174,7 +219,9 @@ export function slackChannel(options) {
                     done: auth.settled
                         .then(() => nativeDmStatus
                         ? api.setThreadStatus(targetOf(turn), "is queued behind an earlier request…")
-                        : api.postMessage(targetOf(turn), QUEUED_PLACEHOLDER).then((ts) => {
+                        : placeApi(turn)
+                            .postMessage(targetOf(turn), QUEUED_PLACEHOLDER)
+                            .then((ts) => {
                             turn.previewTs = ts;
                         }))
                         .catch((error) => log.warn(`${label} queue preview failed (the turn stays durable): ${String(error)}`)),
@@ -198,7 +245,7 @@ export function slackChannel(options) {
                         .catch((error) => log.warn(`${label} could not update a deferred Agent status: ${String(error)}`));
                 }
                 else if (turn.previewTs) {
-                    void settleSlackPreview(api, targetOf(turn), turn.previewTs, DEFERRED_PLACEHOLDER).catch((error) => log.warn(`${label} could not update a deferred queue preview: ${String(error)}`));
+                    void settleSlackPreview(placeApi(turn), targetOf(turn), turn.previewTs, DEFERRED_PLACEHOLDER).catch((error) => log.warn(`${label} could not update a deferred queue preview: ${String(error)}`));
                 }
             },
             notifyDropped,
@@ -210,7 +257,7 @@ export function slackChannel(options) {
                         .setThreadStatus(targetOf(turn), "")
                         .catch((error) => log.warn(`${label} could not clear a queued Agent status: ${String(error)}`));
                 }
-                await deliverSlackAnswer(api, targetOf(turn), answer, turn.previewTs);
+                await deliverSlackAnswer(placeApi(turn), targetOf(turn), answer, turn.previewTs);
                 // The 👀 on the asker's message was added by the run that produced this answer, and `execute`'s
                 // acquire/release — the only thing that turns it into ✅ — is not on this path.
                 const messageRef = messageRefOf(turn.id);
@@ -234,10 +281,15 @@ export function slackChannel(options) {
                         emojis: reactionEmojis,
                         label,
                     })
-                    : undefined), () => Effect.scoped(slackReply(slackTurnStream(agent, turn.session, `${discussionBlock(discussion.text)}${turn.baseText}`, { api, channelId: turn.channelId, filesDir: attachmentsDir(stateHome), label }, {
+                    : undefined), () => Effect.scoped(slackReply(slackTurnStream(agent, {
+                    session: () => sessionFor(turn.conversation),
+                    ...enterRoom(turn),
+                    key: turn.id,
+                    text: `${discussionBlock(discussion.text)}${turn.baseText}`,
+                }, { api, channelId: turn.channelId, filesDir: attachmentsDir(stateHome), label }, {
                     primaryFileIds: turn.fileIds,
-                    buffered: collectSlackBufferedFiles(discussion.consumed, new Set(turn.fileIds)),
-                }), api, targetOf(turn), formatError, {
+                    buffered: collectFoldedFiles(discussion.consumed.flatMap((read) => read.folded), new Set(turn.fileIds)),
+                }), placeApi(turn), targetOf(turn), formatError, {
                     rendering,
                     initialPreviewTs: turn.previewTs,
                     threadTitle: turn.threadTitle,
@@ -249,7 +301,10 @@ export function slackChannel(options) {
                         await reaction?.complete();
                     else
                         await reaction?.remove();
-                }).pipe(Effect.orDie));
+                }).pipe(
+                // A release does not fail: its defect would make the turn's typed failure one too. Unreachable while
+                // the reaction's `complete` and `remove` catch their own failures (reaction.ts).
+                Effect.catchTag("PortFailure", (error) => Effect.sync(() => log.warn(`${label} could not settle the Slack reaction: ${String(error.cause)}`)))));
             },
         });
         let seq = runner.recover().reduce((maximum, turn) => Math.max(maximum, turn.seq), 0);
@@ -275,16 +330,13 @@ export function slackChannel(options) {
             const group = isSlackGroupMessage(event);
             const direct = isSlackDirectMessage(event);
             const rootTs = event.thread_ts ?? event.ts;
-            const bufferKey = slackPlaceKey(teamId, event);
             // Listening is not speaking: every message the channel can see refines who takes part in its thread, whether or
             // not it is answered.
             if (group && event.thread_ts !== undefined) {
                 threadParticipants.merge(threadKey(teamId, event.channel, event.thread_ts), { humans: [event.user] });
             }
             let routed = decide(envelope);
-            // Two different questions (see parse.ts).
             const addressesSomeone = hasSlackMention(event.text ?? "");
-            const mightBeTheBot = hasSlackUserMention(event.text ?? "");
             const structurallyMentionsBot = botUserId !== undefined && mentionsSlackUser(event.text ?? "", botUserId);
             // app_mention and message.* subscriptions can overlap.
             if (!routed && route === undefined && group && event.type === "message" && structurallyMentionsBot)
@@ -303,23 +355,8 @@ export function slackChannel(options) {
                 routed = {};
             }
             if (!routed) {
-                if (route === undefined && group && botUserId === undefined && mightBeTheBot)
-                    return;
-                if (route === undefined && group) {
-                    const body = slackBufferText(slackMessageText(event));
-                    if (body) {
-                        const fileIds = slackFileIds(event);
-                        buffer.push(bufferKey, {
-                            sender: slackSenderLabel(event),
-                            body,
-                            messageId: event.ts,
-                            replyTo: event.thread_ts,
-                            fileIds: fileIds.length ? fileIds : undefined,
-                        });
-                        seen.add(logicalId);
-                        log.debug(`${label} buffered unsummoned group message ${logicalId} (place ${bufferKey})`);
-                    }
-                }
+                // Not lost: the turn that is summoned here reads it from the place's history.
+                log.debug(`${label} not summoned — message ${logicalId}`);
                 return;
             }
             const targetChannel = routed.channelId ?? event.channel;
@@ -327,13 +364,20 @@ export function slackChannel(options) {
             // Answer where asked (participant model §4).
             const defaultThread = event.thread_ts ?? event.ts;
             const threadTs = routed.threadTs === null ? undefined : (routed.threadTs ?? (sameChannel ? defaultThread : undefined));
-            const defaultSession = threadKey(teamId, event.channel, rootTs);
+            const defaultConversation = threadKey(teamId, event.channel, rootTs);
+            // Every place's discussion under the default routing, a DM's too (what a send tool posted there is in no session);
+            // a routed session's place is the router's to decide.
+            const historyKey = route === undefined && (group || direct)
+                ? slackHistoryKey(teamId, { channelId: event.channel, threadTs: event.thread_ts })
+                : undefined;
             // Explicit user stop: a control action, never a turn — it must not queue behind the run it stops.
             if (isStopText(stripSlackMentions(event.text ?? ""))) {
                 seen.add(logicalId);
                 const target = { channelId: event.channel, threadTs: event.thread_ts };
-                sideTasks.track(dispatchStop(control, routed.session ?? defaultSession, label)
-                    .then((feedback) => api.postMessage(target, feedback).then(() => undefined))
+                sideTasks.track(dispatchStop(agent, recordedSession(routed.conversation ?? defaultConversation), label)
+                    .then((feedback) => placeApi({ historyKey, teamId })
+                    .postMessage(target, feedback)
+                    .then(() => undefined))
                     .catch((error) => log.warn(`${label} stop feedback failed: ${String(error)}`)));
                 return;
             }
@@ -347,9 +391,10 @@ export function slackChannel(options) {
             runner.submit({
                 id: logicalId,
                 seq: ++seq,
-                session: routed.session ?? defaultSession,
+                conversation: routed.conversation ?? defaultConversation,
                 baseText,
-                bufferKey,
+                ...(historyKey !== undefined ? { historyKey } : {}),
+                group,
                 teamId,
                 channelId: targetChannel,
                 threadTs,
@@ -362,7 +407,7 @@ export function slackChannel(options) {
             if (group &&
                 threadTs !== undefined &&
                 sameChannel &&
-                routed.session === undefined &&
+                routed.conversation === undefined &&
                 routed.threadTs === undefined) {
                 // The ASKER counts as heard in this thread too, and both halves are written together so the record can never
                 // say "the agent takes part and nobody has spoken".

package/dist/channels/slack/welcomed.js

@@ -1,6 +1,6 @@
 /** Durable set of users who have already received the first-run DM welcome, so it is sent at most once. */
 import { log } from "../../log.js";
-import { loadStateFile, saveStateFile } from "../kit/state.js";
+import { loadStateFile, saveStateFile } from "../../state-file.js";
 function key(teamId, userId) {
     return `${teamId}:${userId}`;
 }

package/dist/channels/telegram/context-buffer.d.ts

@@ -1,4 +1,3 @@
-/** Telegram's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts). */
 import { type ContextBuffer as GenericContextBuffer } from "../kit/context-buffer.ts";
 /** One buffered un-summoned message (object identity is the commit key). */
 export interface BufferEntry {
@@ -31,5 +30,11 @@ export declare function collectAttachments(consumed: BufferEntry[], primary: {
     images: BufferedRef[];
     skipped: number;
 };
+/**
+ * A message the agent sent itself (through `telegramTransport`), as the place's discussion: the agent never receives
+ * its own messages as updates (and the Bot API has no history read), so this is the only way the chat's next turn
+ * knows it was said. The label says only what the transport knows — the agent sent it — not which tool did.
+ */
+export declare function ownPostEntry(body: string, messageId: number | undefined): BufferEntry;
 export type ContextBuffer = GenericContextBuffer<BufferEntry>;
 export declare function createContextBuffer(path: string): ContextBuffer;

package/dist/channels/telegram/context-buffer.js

@@ -1,4 +1,5 @@
 /** Telegram's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts). */
+import { truncateCodePointPrefix } from "../kit/text.js";
 import { capBufferedRefs, createContextBuffer as createGenericContextBuffer, } from "../kit/context-buffer.js";
 function bufferLine(e) {
     const meta = [
@@ -28,6 +29,24 @@ export function collectAttachments(consumed, primary) {
     const images = capBufferedRefs(refs((e) => e.imageIds, primary.images));
     return { files: files.kept, images: images.kept, skipped: files.skipped + images.skipped };
 }
+/**
+ * How much of a message the agent sent itself a place keeps. A digest runs to thousands of characters, and the
+ * per-line bound a human message gets would keep its title only; this stays inside the buffer's budget, so later
+ * discussion still evicts it oldest-first.
+ */
+const OWN_POST_MAX_CHARS = 2000;
+/**
+ * A message the agent sent itself (through `telegramTransport`), as the place's discussion: the agent never receives
+ * its own messages as updates (and the Bot API has no history read), so this is the only way the chat's next turn
+ * knows it was said. The label says only what the transport knows — the agent sent it — not which tool did.
+ */
+export function ownPostEntry(body, messageId) {
+    return {
+        sender: "you (sent by the agent)",
+        body: truncateCodePointPrefix(body.replace(/\s+/g, " ").trim(), OWN_POST_MAX_CHARS, " … (truncated)"),
+        messageId,
+    };
+}
 function isBufferEntry(e) {
     const t = e;
     const strings = (v) => v === undefined || (Array.isArray(v) && v.every((x) => typeof x === "string"));

package/dist/channels/telegram/invoke-turn.d.ts

@@ -4,10 +4,10 @@
  * Split from parse.ts because this half touches the Bot API + disk; split from telegram.ts so the
  * factory keeps only wiring and the per-turn lifecycle.
  */
-import type { Agent, AgentEvent } from "../../agent.ts";
+import type { Agent } from "../../agent-api.ts";
 import type * as Stream from "effect/Stream";
 import type { PortFailure } from "../../effect-port.ts";
-import { type BusyRetry } from "../kit/invoke-turn-kit.ts";
+import { type TurnEvent } from "../kit/invoke-turn-kit.ts";
 import type { BufferedRef } from "./context-buffer.ts";
 /** Everything the transport needs to fetch a turn's attachments. */
 export interface TurnTransport {
@@ -31,6 +31,10 @@ export interface TurnAttachments {
 }
 /**
  * Run one turn: resolve its attachments, then ask the agent (invoke-turn-kit — a primary-attachment
- * failure surfaces as a `failed` event, never a silent drop).
+ * failure surfaces as a `rejected` event, never a silent drop). `key` is the turn's: the update it answers.
  */
-export declare function telegramTurnStream(agent: Agent, session: string, text: string, transport: TurnTransport, attachments: TurnAttachments, busyRetry?: BusyRetry): Stream.Stream<AgentEvent, PortFailure>;
+export declare function telegramTurnStream(agent: Agent, turn: {
+    session: () => Promise<string>;
+    key: string;
+    text: string;
+}, transport: TurnTransport, attachments: TurnAttachments): Stream.Stream<TurnEvent, PortFailure>;