@agentconnect.md/daemon 1.0.0-rc.32 → 1.0.0-rc.33

package/dist/index.js

@@ -7353,6 +7353,7 @@ const RuntimeDefSchema = object({
 const ConfigSchema = object({
 	version: literal(1),
 	daemonId: string().optional(),
+	webAppUrl: string().optional(),
 	controlPlane: object({
 		enabled: boolean().default(true),
 		url: string().optional(),
@@ -7374,11 +7375,13 @@ const ConfigSchema = object({
 	limits: object({
 		maxAgents: number().int().default(8),
 		maxConcurrentSessions: number().int().default(32),
-		agentIdleTimeoutMs: number().int().default(9e5)
+		agentIdleTimeoutMs: number().int().default(9e5),
+		maxAttachmentBytes: number().int().default(8 * 1024 * 1024)
 	}).default({
 		maxAgents: 8,
 		maxConcurrentSessions: 32,
-		agentIdleTimeoutMs: 9e5
+		agentIdleTimeoutMs: 9e5,
+		maxAttachmentBytes: 8 * 1024 * 1024
 	})
 });
 //#endregion
@@ -16877,6 +16880,7 @@ var AcpHost = class {
 	live = /* @__PURE__ */ new Set();
 	loadingSessions = /* @__PURE__ */ new Set();
 	canLoad = false;
+	promptCaps = {};
 	constructor(runtime, opts) {
 		this.runtime = runtime;
 		this.opts = opts;
@@ -16917,7 +16921,13 @@ var AcpHost = class {
 			} }
 		});
 		this.canLoad = init.agentCapabilities?.loadSession ?? false;
-		this.opts.log?.debug(`acp: agent initialized (loadSession capability=${this.canLoad})`);
+		this.promptCaps = init.agentCapabilities?.promptCapabilities ?? {};
+		this.opts.log?.debug(`acp: agent initialized (loadSession=${this.canLoad}, prompt caps: image=${!!this.promptCaps.image} audio=${!!this.promptCaps.audio} embeddedContext=${!!this.promptCaps.embeddedContext})`);
+	}
+	/** Whether the agent advertised support for a gated prompt content-block kind.
+	*  `text` and `resource_link` are baseline and always return true. */
+	promptSupports(kind) {
+		return Boolean(this.promptCaps[kind]);
 	}
 	async newSession(cwd, mcpServers = []) {
 		const res = await this.conn.agent.request(methods.agent.session.new, {
@@ -23265,6 +23275,12 @@ var LocalStore = class {
 	openSessionAgents(channel, thread) {
 		return this.db.prepare("SELECT agentId FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed'").all(channel, thread).map((r) => r.agentId);
 	}
+	/** Count non-closed sessions in (channel, thread) touched at/after `sinceTs`
+	*  (epoch ms). Used to bound unrouted-transcript growth to recently-active
+	*  threads, since there is no session-`closed` lifecycle yet. */
+	activeSessionCountSince(channel, thread, sinceTs) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed' AND updatedAt >= ?").get(channel, thread, sinceTs)?.n ?? 0;
+	}
 	getCpRouting() {
 		return this.db.prepare("SELECT routingEpoch, assignments, globalRules FROM cp_routing WHERE id = 1").get();
 	}
@@ -23281,6 +23297,67 @@ var LocalStore = class {
 	}
 };
 //#endregion
+//#region src/session/attachment-block.ts
+/**
+* Turn one Slack attachment into the richest ACP content block the agent can
+* accept (§9.2):
+*  - image/* + promptCapabilities.image  → an inline `image` block (base64).
+*  - downloaded + promptCapabilities.embeddedContext → an embedded `resource`
+*    (text bytes for text/*, else a base64 blob).
+*  - otherwise → a baseline `resource_link` pointer (always supported), which is
+*    also the fallback when the download failed or the agent opted out.
+*/
+function attachmentToBlock(att, bytes, supports) {
+	const isImage = att.mimeType.startsWith("image/");
+	if (bytes && isImage && supports("image")) return {
+		type: "image",
+		data: bytes.toString("base64"),
+		mimeType: att.mimeType,
+		uri: att.sourceUrl
+	};
+	if (bytes && supports("embeddedContext")) {
+		if (att.mimeType.startsWith("text/")) return {
+			type: "resource",
+			resource: {
+				text: bytes.toString("utf8"),
+				uri: att.sourceUrl,
+				mimeType: att.mimeType
+			}
+		};
+		return {
+			type: "resource",
+			resource: {
+				blob: bytes.toString("base64"),
+				uri: att.sourceUrl,
+				mimeType: att.mimeType
+			}
+		};
+	}
+	return {
+		type: "resource_link",
+		name: att.name,
+		uri: att.sourceUrl,
+		mimeType: att.mimeType,
+		description: `Slack file. You cannot fetch this URL directly — call the readSlackFile tool with this uri (mimeType: ${att.mimeType}) to view its contents.`,
+		...typeof att.size === "number" ? { size: att.size } : {}
+	};
+}
+/** Download + convert every attachment, skipping nothing (failed/over-cap
+*  downloads degrade to resource_link rather than being dropped). A file whose
+*  declared size already exceeds maxBytes is never fetched. */
+async function buildAttachmentBlocks(attachments, deps) {
+	const cap = deps.maxBytes ?? Infinity;
+	return Promise.all(attachments.map(async (att) => {
+		return attachmentToBlock(att, typeof att.size === "number" && att.size > cap ? null : await deps.download(att).catch(() => null), deps.supports);
+	}));
+}
+/** One-line human summary of attachments for the transcript text (so §8.5
+*  catch-up replay at least notes a file was shared, since bytes aren't stored). */
+function attachmentMention(attachments) {
+	if (!attachments?.length) return "";
+	return `[attached: ${attachments.map((a) => `${a.name} (${a.mimeType})`).join(", ")}]`;
+}
+//#endregion
 //#region src/session/session-manager.ts
 var SessionManager = class {
 	deps;
@@ -23294,14 +23371,15 @@ var SessionManager = class {
 	async handle(agentId, msg) {
 		const agent = this.deps.agentById(agentId);
 		if (!agent) throw new Error(`unknown agent ${agentId}`);
-		const thread = msg.thread ?? msg.msgId;
+		const { thread, ts } = transcriptCoords(msg);
 		const key = sessionKey(msg.platform, msg.channel, thread, agentId);
+		const mention = attachmentMention(msg.attachments);
 		this.deps.store.appendTranscript({
 			channel: msg.channel,
 			thread,
-			ts: tsOf(msg),
+			ts,
 			sender: msg.sender.id,
-			text: msg.text
+			text: mention ? `${msg.text}\n${mention}`.trim() : msg.text
 		});
 		let rec = this.deps.store.getSession(key);
 		const host = await this.deps.hostFor(agentId);
@@ -23349,21 +23427,44 @@ var SessionManager = class {
 				this.deps.store.upsertSession(rec);
 			}
 		}
+		if (rec.lastDeliveredTs === null && thread !== ts && this.deps.fetchThreadHistory) {
+			if (!this.deps.store.transcriptSince(msg.channel, thread, null).some((e) => e.ts === thread)) {
+				const history = await this.deps.fetchThreadHistory(agentId, msg.channel, thread);
+				for (const h of history) this.deps.store.appendTranscript({
+					channel: msg.channel,
+					thread,
+					ts: h.ts,
+					sender: h.sender,
+					text: h.text
+				});
+			}
+		}
 		const gap = this.deps.store.transcriptSince(msg.channel, thread, rec.lastDeliveredTs);
 		const blocks = [];
-		const context = gap.slice(0, -1).filter((e) => e.sender !== agentId);
+		const allContext = gap.filter((e) => e.ts !== ts).filter((e) => e.sender !== agentId);
+		const context = allContext.slice(-50);
 		if (context.length > 0) {
+			const elided = allContext.length - context.length;
+			const head = elided > 0 ? `(thread context you may have missed — ${elided} earlier message(s) elided)` : "(thread context you may have missed)";
 			const ctxText = context.map((e) => `[${e.sender}] ${e.text}`).join("\n");
 			blocks.push({
 				type: "text",
-				text: `(thread context you may have missed)\n${ctxText}`
+				text: `${head}\n${ctxText}`
 			});
 		}
 		blocks.push({
 			type: "text",
 			text: msg.text
 		});
-		rec.lastDeliveredTs = tsOf(msg);
+		if (msg.attachments?.length) {
+			const attBlocks = await buildAttachmentBlocks(msg.attachments, {
+				download: (att) => this.deps.downloadAttachment?.(agentId, att) ?? Promise.resolve(null),
+				supports: (kind) => host.promptSupports?.(kind) ?? false,
+				...this.deps.attachmentMaxBytes !== void 0 ? { maxBytes: this.deps.attachmentMaxBytes } : {}
+			});
+			blocks.push(...attBlocks);
+		}
+		rec.lastDeliveredTs = ts;
 		rec.state = "prompting";
 		rec.updatedAt = Date.now();
 		this.deps.store.upsertSession(rec);
@@ -23373,9 +23474,17 @@ var SessionManager = class {
 		};
 	}
 };
-function tsOf(msg) {
+/** Canonical transcript primary-key coordinates for a normalized message. Used by
+*  BOTH the session manager and the daemon's unrouted-append path so a message
+*  recorded from either site lands on the same (thread, ts) PK and dedups via
+*  INSERT OR IGNORE — never a divergent double row. */
+function transcriptCoords(msg) {
+	const thread = msg.thread ?? msg.msgId;
 	const parts = msg.msgId.split(":");
-	return parts[parts.length - 1] ?? "0";
+	return {
+		thread,
+		ts: parts[parts.length - 1] ?? "0"
+	};
 }
 //#endregion
 //#region src/mcp/ipc.ts
@@ -23411,6 +23520,25 @@ function decodeFrames(buf, onError) {
 }
 //#endregion
 //#region src/mcp/ops.ts
+const DEFAULT_MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+/** Best-effort MIME guess from a Slack file URL's extension (used when the caller
+*  doesn't pass a mimeType hint). */
+function guessMimeFromUrl(url) {
+	const ext = url.split("?")[0]?.split(".").pop()?.toLowerCase();
+	return ext ? {
+		png: "image/png",
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		gif: "image/gif",
+		webp: "image/webp",
+		bmp: "image/bmp",
+		svg: "image/svg+xml",
+		txt: "text/plain",
+		md: "text/markdown",
+		json: "application/json",
+		csv: "text/csv"
+	}[ext] : void 0;
+}
 /**
 * Execute one tool call inside the daemon and return a plain result object (the
 * bridge wraps it into an MCP `CallToolResult`). Throws on bad input or a
@@ -23454,6 +23582,26 @@ async function executeTool(ctx, name, args, deps) {
 			const user = requireString(args, "user");
 			return await gw.getUserProfile(user);
 		}
+		case "readSlackFile": {
+			const url = requireString(args, "url");
+			const max = deps.maxAttachmentBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES;
+			const bytes = await gw.downloadFile(url, max);
+			if (!bytes) throw new Error(`could not download the Slack file at ${url} — the bot may lack the files:read scope, or the file is inaccessible / larger than ${max} bytes`);
+			const mimeType = optionalString(args, "mimeType") ?? guessMimeFromUrl(url) ?? "application/octet-stream";
+			if (mimeType.startsWith("image/")) return { mcpContent: [{
+				type: "image",
+				data: bytes.toString("base64"),
+				mimeType
+			}] };
+			if (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "text/csv") return { mcpContent: [{
+				type: "text",
+				text: bytes.toString("utf8")
+			}] };
+			return { mcpContent: [{
+				type: "text",
+				text: `Downloaded ${bytes.byteLength} bytes of ${mimeType} (binary — not shown inline).`
+			}] };
+		}
 		default: throw new Error(`unknown tool: ${name}`);
 	}
 }
@@ -23665,6 +23813,20 @@ const SLACK_TOOLS = [
 			type: "string",
 			description: "User ID (e.g. U0123ABC)."
 		} }, ["user"])
+	},
+	{
+		name: "readSlackFile",
+		description: "Fetch the contents of a file shared in Slack, using the bot credentials. You do NOT have direct network access to Slack's private file URLs (they require the bot token) — use this tool instead of curl/fetch. Pass the file's `url` (the `url_private` / `uri` from a shared attachment or resource link). Images are returned as viewable image content; text files as text. Supply `mimeType` when known for correct handling.",
+		inputSchema: obj({
+			url: {
+				type: "string",
+				description: "The file's url_private (or url_private_download) / resource-link uri."
+			},
+			mimeType: {
+				type: "string",
+				description: "Optional MIME type hint, e.g. image/png or text/plain."
+			}
+		}, ["url"])
 	}
 ];
 SLACK_TOOLS.map((t) => t.name);
@@ -79691,9 +79853,25 @@ var import_dist = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((expor
 	});
 })))(), 1);
 const MENTION_RE = /<@([A-Z0-9]+)>/g;
+/** Map a Slack file element to a NormalizedMessage Attachment, dropping any
+*  without a usable id + fetch URL (e.g. external/tombstoned files). Tolerates a
+*  malformed (null / non-object) element off the wire without throwing. */
+function toAttachment(f) {
+	if (!f || typeof f !== "object") return null;
+	const sourceUrl = f.url_private_download ?? f.url_private;
+	if (!f.id || !sourceUrl) return null;
+	return {
+		id: f.id,
+		name: f.name ?? f.title ?? f.id,
+		mimeType: f.mimetype ?? "application/octet-stream",
+		...typeof f.size === "number" ? { size: f.size } : {},
+		sourceUrl
+	};
+}
 function normalizeSlackEvent(event, ctx) {
 	const text = event.text ?? "";
 	const mentionedBots = [...text.matchAll(MENTION_RE)].map((m) => m[1]);
+	const attachments = (event.files ?? []).map(toAttachment).filter((a) => a !== null);
 	return {
 		msgId: `slack:${event.channel}:${event.ts}`,
 		traceId: ctx.traceId,
@@ -79707,10 +79885,75 @@ function normalizeSlackEvent(event, ctx) {
 		},
 		text,
 		mentionedBots,
+		...attachments.length ? { attachments } : {},
 		isDm: event.channel_type === "im"
 	};
 }
 //#endregion
+//#region src/slack/send-queue.ts
+/**
+* §9.1 SlackSendQueue: serialize outbound Slack Web API writes (chat.postMessage
+* / chat.update / assistant.threads.setStatus) per connection and space them by a
+* minimum interval so streamed edits don't trip Slack's Tier-3 rate limit
+* (chat.postMessage ~50 rpm). FIFO: preserves the order the converger emits.
+*
+* The first task runs immediately; each subsequent task waits until at least
+* `minIntervalMs` after the previous one *started*. `enqueue` resolves/rejects
+* with the task's own result, so callers can still await a posted message ts.
+*
+* Each task is bounded by `taskTimeoutMs`: if a single call hangs (e.g. a Slack
+* API stall during a socket reconnect), it is abandoned so the queue keeps moving
+* and a best-effort status update can never block real message delivery. The
+* abandoned call's promise still settles in the background; the caller just sees a
+* timeout rejection (which, for a progress/plan post, the daemon treats as "no ts").
+*/
+var SlackSendQueue = class {
+	minIntervalMs;
+	now;
+	sleep;
+	taskTimeoutMs;
+	chain = Promise.resolve();
+	lastStart = Number.NEGATIVE_INFINITY;
+	constructor(minIntervalMs = 350, now = () => Date.now(), sleep = (ms) => new Promise((r) => setTimeout(r, ms)), taskTimeoutMs = 3e4) {
+		this.minIntervalMs = minIntervalMs;
+		this.now = now;
+		this.sleep = sleep;
+		this.taskTimeoutMs = taskTimeoutMs;
+	}
+	enqueue(task) {
+		const run = this.chain.then(async () => {
+			const wait = this.minIntervalMs - (this.now() - this.lastStart);
+			if (wait > 0) await this.sleep(wait);
+			this.lastStart = this.now();
+			return this.withTimeout(task());
+		});
+		this.chain = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	withTimeout(p) {
+		if (!Number.isFinite(this.taskTimeoutMs) || this.taskTimeoutMs <= 0) return p;
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const timer = setTimeout(() => {
+				if (settled) return;
+				settled = true;
+				reject(/* @__PURE__ */ new Error(`SlackSendQueue: task exceeded ${this.taskTimeoutMs}ms — abandoned`));
+			}, this.taskTimeoutMs);
+			p.then((v) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(v);
+			}, (e) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				reject(e);
+			});
+		});
+	}
+};
+//#endregion
 //#region src/slack/connection.ts
 const { App, LogLevel } = import_dist.default;
 /** §6.1: one Slack Socket Mode connection per unique appToken. */
@@ -79737,15 +79980,21 @@ const MEMBER_ENRICH_CAP = 50;
 var SlackConnection = class {
 	deps;
 	app;
+	queue;
 	botUserId = "";
 	/** The appToken this socket is keyed by (one socket per unique appToken). */
 	appToken;
 	/** The botToken this socket authenticated with (used to detect a same-appToken swap). */
 	botToken;
+	botId = "";
 	constructor(deps, factory = (o) => new App({
 		token: o.token,
 		appToken: o.appToken,
 		socketMode: true,
+		clientOptions: {
+			timeout: 1e4,
+			retryConfig: { retries: 2 }
+		},
 		...deps.boltDebug ? { logLevel: LogLevel.DEBUG } : {}
 	})) {
 		this.deps = deps;
@@ -79755,13 +80004,15 @@ var SlackConnection = class {
 			token: deps.group.botToken,
 			appToken: deps.group.appToken
 		});
+		this.queue = new SlackSendQueue(deps.sendIntervalMs ?? 350);
 	}
 	async start() {
 		const log = this.deps.log;
 		log?.debug("slack: auth.test → resolving bot identity (HTTPS)…");
 		const auth = await this.app.client.auth.test();
 		this.botUserId = auth.user_id ?? "";
-		log?.debug(`slack: auth.test ok → bot user ${this.botUserId}`);
+		this.botId = auth.bot_id ?? "";
+		log?.debug(`slack: auth.test ok → bot user ${this.botUserId} (bot_id ${this.botId || "n/a"})`);
 		const deliver = (ev, kind) => {
 			const msg = normalizeSlackEvent(ev, { traceId: this.deps.newTraceId() });
 			log?.debug(`slack: inbound ${kind} ch=${msg.channel} user=${msg.sender.id} isBot=${msg.sender.isBot} isDm=${msg.isDm} mentions=[${msg.mentionedBots.join(",")}] text=${JSON.stringify(msg.text.slice(0, 80))}`);
@@ -79785,11 +80036,97 @@ var SlackConnection = class {
 		log?.debug("slack: app.start resolved → socket established");
 	}
 	async postMessage(channel, text, threadTs) {
-		return (await this.app.client.chat.postMessage({
-			channel,
-			text,
-			thread_ts: threadTs
-		}))?.ts;
+		return this.queue.enqueue(async () => {
+			return (await this.app.client.chat.postMessage({
+				channel,
+				text,
+				thread_ts: threadTs
+			}))?.ts;
+		});
+	}
+	/** Edit a previously-posted message in place (chat.update) — the §9.1 "就地更新"
+	*  primitive for the main progress / plan message. Best-effort: swallows errors. */
+	async updateMessage(channel, ts, text) {
+		await this.queue.enqueue(async () => {
+			try {
+				await this.app.client.chat.update({
+					channel,
+					ts,
+					text
+				});
+			} catch (err) {
+				this.deps.log?.debug(`slack: chat.update failed (ch=${channel} ts=${ts}): ${err.message}`);
+			}
+		});
+	}
+	/**
+	* Pull a Slack thread's full history (conversations.replies, cursor-paginated)
+	* for §8.4/§9.2 mid-thread context. Returns root + replies in Slack ts order;
+	* best-effort (returns what it fetched, [] on error). Bot/system frames keep
+	* their bot_id as the sender so the caller can attribute them.
+	*/
+	async getThreadReplies(channel, threadTs, maxMessages = 200) {
+		const out = [];
+		let cursor;
+		try {
+			do {
+				const res = await this.app.client.conversations.replies({
+					channel,
+					ts: threadTs,
+					limit: 200,
+					...cursor ? { cursor } : {}
+				});
+				for (const m of res.messages ?? []) {
+					if (!m.ts) continue;
+					out.push({
+						sender: m.user ?? m.bot_id ?? "unknown",
+						ts: m.ts,
+						text: m.text ?? "",
+						isBot: Boolean(m.bot_id),
+						attachments: (m.files ?? []).map(toAttachment).filter((a) => a !== null)
+					});
+					if (out.length >= maxMessages) return out;
+				}
+				cursor = res.has_more ? res.response_metadata?.next_cursor : void 0;
+			} while (cursor);
+		} catch (err) {
+			this.deps.log?.debug(`slack: conversations.replies failed (ch=${channel} thread=${threadTs}): ${err.message}`);
+		}
+		return out;
+	}
+	/**
+	* Download an auth-gated Slack file (url_private[_download]) with the bot token,
+	* up to `maxBytes` (bounds daemon RSS + the inlined prompt frame). Returns the
+	* bytes, or null on any failure / over-cap (best-effort — a failed or oversized
+	* attachment degrades to a resource_link, never breaks the prompt). §9.2: bytes
+	* stay daemon-local.
+	*/
+	async downloadFile(sourceUrl, maxBytes = 8 * 1024 * 1024) {
+		try {
+			const res = await fetch(sourceUrl, { headers: { Authorization: `Bearer ${this.deps.group.botToken}` } });
+			if (!res.ok) {
+				this.deps.log?.debug(`slack: downloadFile ${sourceUrl} → HTTP ${res.status}`);
+				return null;
+			}
+			const declared = Number(res.headers.get("content-length"));
+			if (Number.isFinite(declared) && declared > maxBytes) {
+				this.deps.log?.debug(`slack: downloadFile ${sourceUrl} skipped — ${declared} bytes > cap ${maxBytes}`);
+				return null;
+			}
+			if ((res.headers.get("content-type") ?? "").includes("text/html")) {
+				this.deps.log?.debug(`slack: downloadFile ${sourceUrl} got text/html (login page?) — treating as inaccessible`);
+				return null;
+			}
+			const buf = Buffer.from(await res.arrayBuffer());
+			if (buf.byteLength > maxBytes) {
+				this.deps.log?.debug(`slack: downloadFile ${sourceUrl} discarded — ${buf.byteLength} bytes > cap ${maxBytes}`);
+				return null;
+			}
+			return buf;
+		} catch (err) {
+			this.deps.log?.debug(`slack: downloadFile ${sourceUrl} failed: ${err.message}`);
+			return null;
+		}
 	}
 	async getChannelInfo(channel) {
 		const c = (await this.app.client.conversations.info({ channel })).channel ?? {};
@@ -79837,22 +80174,103 @@ var SlackConnection = class {
 	* Pass status='' to clear. Never throws into dispatch.
 	*/
 	async setStatus(channel, threadTs, status, loadingMessages) {
-		try {
-			await this.app.client.assistant.threads.setStatus({
-				channel_id: channel,
-				thread_ts: threadTs,
-				status,
-				...loadingMessages ? { loading_messages: loadingMessages } : {}
-			});
-		} catch (err) {
-			this.deps.log?.debug(`slack: setStatus failed (ch=${channel} thread=${threadTs}): ${err.message}`);
-		}
+		await this.queue.enqueue(async () => {
+			try {
+				await this.app.client.assistant.threads.setStatus({
+					channel_id: channel,
+					thread_ts: threadTs,
+					status,
+					...loadingMessages ? { loading_messages: loadingMessages } : {}
+				});
+			} catch (err) {
+				this.deps.log?.debug(`slack: setStatus failed (ch=${channel} thread=${threadTs}): ${err.message}`);
+			}
+		});
 	}
 	async stop() {
 		await this.app.stop();
 	}
 };
 //#endregion
+//#region src/slack/formatter.ts
+/**
+* Last-mile Slack formatting (§9.1 / §9.3). Two pure helpers:
+*  - markdownToMrkdwn: convert the agent's CommonMark-ish output to Slack mrkdwn.
+*  - splitIntoSections: break a message into <= maxLen sections (Slack ~3000/section).
+* Both are platform-specific; the upstream convergence (ACP->IR) stays platform-agnostic.
+*/
+/** Slack section soft cap (§9.3: Slack splits at ~3000 chars per section). */
+const SLACK_SECTION_LIMIT = 3e3;
+const CODE_SENTINEL = "\0";
+const BOLD = "
";
+/** Replace fenced ```code``` and inline `code` with placeholders so inline
+*  formatting rules never fire inside them; returns the masked text + restorer. */
+function protectCode(input) {
+	const spans = [];
+	const masked = input.replace(/```[\s\S]*?```|`[^`\n]*`/g, (m) => {
+		return `${CODE_SENTINEL}${spans.push(m) - 1}${CODE_SENTINEL}`;
+	});
+	const restore = (s) => s.replace(new RegExp(`${CODE_SENTINEL}(\\d+)${CODE_SENTINEL}`, "g"), (_, i) => spans[Number(i)] ?? "");
+	return {
+		masked,
+		restore
+	};
+}
+/**
+* Convert common Markdown to Slack mrkdwn. Handled: bold (`**`/`__` -> `*`),
+* italic (`*` -> `_`; bare `_` is already valid mrkdwn italic and left alone to
+* avoid mangling snake_case), strikethrough (`~~` -> `~`), links (`[t](u)` ->
+* `<u|t>`), ATX headings (`# H` -> `*H*`), and `-`/`*`/`+` bullets -> `•`. Code
+* spans and fences are preserved verbatim.
+*
+* Best-effort, not a full CommonMark parser: pathological overlapping emphasis
+* (e.g. `***a** b*`, or a lone `*` inside `**bold**`) can still render imperfectly.
+* Such inputs are rare in agent output and only affect cosmetics — never content.
+*/
+function markdownToMrkdwn(input) {
+	if (!input) return input;
+	const { masked, restore } = protectCode(input);
+	let out = masked;
+	out = out.replace(/^[ \t]*#{1,6}[ \t]+(.+?)[ \t]*#*$/gm, (_m, h) => `${BOLD}${h.replace(/\*+|__/g, "")}${BOLD}`);
+	out = out.replace(/^([ \t]*)[-*+][ \t]+/gm, "$1• ");
+	out = out.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "<$2|$1>");
+	out = out.replace(/\*\*\*(?!\s)([^\n]+?)(?<!\s)\*\*\*/g, `${BOLD}_$1_${BOLD}`);
+	out = out.replace(/___(?!\s)([^\n]+?)(?<!\s)___/g, `${BOLD}_$1_${BOLD}`);
+	out = out.replace(/\*\*(?!\s)([^\n]+?)(?<!\s)\*\*/g, `${BOLD}$1${BOLD}`);
+	out = out.replace(/__(?!\s)([^\n]+?)(?<!\s)__/g, `${BOLD}$1${BOLD}`);
+	out = out.replace(/\*(?!\s)([^*\n]+?)(?<!\s)\*/g, "_$1_");
+	out = out.split(BOLD).join("*");
+	out = out.replace(/~~([^\n]+?)~~/g, "~$1~");
+	return restore(out);
+}
+/**
+* Split text into sections no longer than maxLen, preferring line boundaries;
+* a single line longer than maxLen is hard-cut. Whitespace-only input yields no
+* sections. Content is never lost across sections.
+*/
+function splitIntoSections(text, maxLen = SLACK_SECTION_LIMIT) {
+	if (!text.trim()) return [];
+	if (text.length <= maxLen) return [text];
+	const sections = [];
+	let cur = "";
+	const flush = () => {
+		if (cur.length) sections.push(cur);
+		cur = "";
+	};
+	for (const line of text.split("\n")) {
+		const piece = cur.length ? `\n${line}` : line;
+		if (cur.length + piece.length <= maxLen) {
+			cur += piece;
+			continue;
+		}
+		flush();
+		if (line.length <= maxLen) cur = line;
+		else for (let i = 0; i < line.length; i += maxLen) sections.push(line.slice(i, i + maxLen));
+	}
+	flush();
+	return sections;
+}
+//#endregion
 //#region src/slack/render.ts
 const THINKING = "is thinking…";
 const MAX_ACTIVITY = 10;
@@ -79861,6 +80279,15 @@ function clampLabel(s) {
 	const t = s.trim();
 	return t.length > MAX_LABEL ? `${t.slice(0, MAX_LABEL - 1)}…` : t;
 }
+function planIcon(status) {
+	if (status === "completed") return ":white_check_mark:";
+	if (status === "in_progress") return ":hourglass_flowing_sand:";
+	return ":white_large_square:";
+}
+/** Render an ACP plan (full entry list, resent on every update) as a compact summary. */
+function renderPlan(entries) {
+	return [":clipboard: *Plan*", ...entries.map((e) => `${planIcon(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
+}
 var OutputConverger = class {
 	mode;
 	buf = "";
@@ -79869,17 +80296,24 @@ var OutputConverger = class {
 	constructor(mode) {
 		this.mode = mode;
 	}
+	/** True while body text is buffered — the daemon uses this to (re)arm the ~2s
+	*  idle-flush timer (§9.1 text-buffer) so a long pure-text stream posts in steps. */
+	hasBuffered() {
+		return this.buf.trim().length > 0;
+	}
+	/** Flush the buffered body: markdown→mrkdwn, then split into ≤3000-char sections,
+	*  one `post` per section (§9.1/§9.3). Public so the daemon's idle timer can call it. */
+	flushBuffered() {
+		return this.flush();
+	}
 	flush() {
-		if (!this.buf.trim()) {
-			this.buf = "";
-			return [];
-		}
 		const text = this.buf;
 		this.buf = "";
-		return [{
+		if (!text.trim()) return [];
+		return splitIntoSections(markdownToMrkdwn(text)).map((t) => ({
 			kind: "post",
-			text
-		}];
+			text: t
+		}));
 	}
 	/**
 	* Record an activity label and build the loading-status action carrying the rolling
@@ -79921,13 +80355,12 @@ var OutputConverger = class {
 						...this.flush(),
 						...status,
 						{
-							kind: "update-main",
-							text: `_thinking: ${content?.text ?? ""}_`
+							kind: "progress",
+							text: `:thought_balloon: ${clampLabel(content?.text ?? "thinking…")}`
 						}
 					];
 				}
-				if (this.mode === "low") return [...this.flush(), ...status];
-				return status;
+				return [...this.flush(), ...status];
 			}
 			case "tool_call":
 			case "tool_call_update": {
@@ -79938,28 +80371,42 @@ var OutputConverger = class {
 					...this.flush(),
 					...status,
 					{
-						kind: "update-main",
+						kind: "progress",
 						text: `:hammer_and_wrench: ${label}`
 					}
 				];
 			}
+			case "plan": {
+				const entries = update.entries ?? [];
+				if (this.mode === "low") return [...this.flush(), ...this.pushActivity("planning…")];
+				return [...this.flush(), {
+					kind: "plan",
+					text: renderPlan(entries)
+				}];
+			}
 			case "usage_update": return [];
 			default: return [];
 		}
 	}
+	/**
+	* Turn end (§9.1 stopReason): flush remaining body, clear the loading status, and
+	* — in medium/high — append a footer linking to the Web App session detail. The
+	* link is omitted entirely when none is configured (no `local://` placeholder).
+	*/
 	onFinal(link) {
 		const clear = {
 			kind: "set-status",
 			text: ""
 		};
 		if (this.mode === "low") return [...this.flush(), clear];
+		const footer = link ? [{
+			kind: "post",
+			text: `:white_check_mark: done — <${link}|details>`
+		}] : [];
 		return [
 			...this.flush(),
 			clear,
-			{
-				kind: "post",
-				text: `:white_check_mark: done — <${link}|details>`
-			}
+			...footer
 		];
 	}
 };
@@ -81440,6 +81887,7 @@ function formatErr(err) {
 	return e?.stack ?? String(err);
 }
 const MAX_QUEUED_PER_SESSION = 10;
+const IDLE_FLUSH_MS = 2e3;
 var Daemon = class {
 	opts;
 	store;
@@ -81530,7 +81978,8 @@ var Daemon = class {
 				ts,
 				sender: ctx.agentId,
 				text
-			})
+			}),
+			maxAttachmentBytes: cfg.limits.maxAttachmentBytes
 		});
 		await this.mcp.start();
 		const cliEntry = process.argv[1] ?? "";
@@ -81554,7 +82003,10 @@ var Daemon = class {
 					token,
 					cliEntry
 				});
-			}
+			},
+			downloadAttachment: (agentId, att) => this.replyConnFor(agentId)?.downloadFile?.(att.sourceUrl, this.cfg.limits.maxAttachmentBytes) ?? Promise.resolve(null),
+			attachmentMaxBytes: cfg.limits.maxAttachmentBytes,
+			fetchThreadHistory: (agentId, channel, threadTs) => this.fetchThreadHistory(agentId, channel, threadTs)
 		});
 		this.scheduler = new Scheduler({
 			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${formatErr(err)}`)),
@@ -81786,12 +82238,63 @@ var Daemon = class {
 		}
 		const result = routeRules(msg, this.mergedRules(), (c, t) => this.sessions.threadOwner(c, t));
 		if (!result) {
+			this.recordUnrouted(msg);
 			this.log.debug(`routing: dropped message in ch=${msg.channel} (no agent matched — not a mention of a known bot, not a subscribed 'all' channel, not a thread/DM hit)`);
 			return;
 		}
 		this.log.info(`routing: ch=${msg.channel} → agent "${result.agentId}" (integration ${result.integrationId})`);
 		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
 	}
+	/** All of our own connections' bot identities (both `U…` user ids and `B…`
+	*  bot_ids), so we recognize self-echoes regardless of which field Slack sends. */
+	ownBotIdentities() {
+		const ids = /* @__PURE__ */ new Set();
+		for (const conn of this.connByIntegration.values()) {
+			if (conn.botUserId) ids.add(conn.botUserId);
+			if (conn.botId) ids.add(conn.botId);
+		}
+		return ids;
+	}
+	/** Record an unrouted inbound message into the transcript iff a session is
+	*  *recently active* in its thread (§8.5 catch-up). Skips our own bot's echoes
+	*  (recordOutbound already logs those under the agentId). The recency gate bounds
+	*  transcript growth to threads with live work — without it, a thread that ever
+	*  held a session would record forever (no session-`closed` lifecycle yet). */
+	recordUnrouted(msg) {
+		if (this.ownBotIdentities().has(msg.sender.id)) return;
+		const { thread, ts } = transcriptCoords(msg);
+		const sinceTs = Date.now() - this.cfg.limits.agentIdleTimeoutMs;
+		const recentlyActive = this.store.activeSessionCountSince(msg.channel, thread, sinceTs) > 0;
+		const inFlight = [...this.pending.values()].some((p) => p.channel === msg.channel && p.statusThread === thread);
+		if (!recentlyActive && !inFlight) return;
+		this.store.appendTranscript({
+			channel: msg.channel,
+			thread,
+			ts,
+			sender: msg.sender.id,
+			text: msg.text
+		});
+		this.log.debug(`transcript: recorded unrouted msg ch=${msg.channel} thread=${thread} ts=${ts} (live session)`);
+	}
+	/**
+	* Pull real Slack thread history for a cold mid-thread @ (§8.4/§9.2), relabeling
+	* THIS agent's own past bot frames to its agentId (so the §8.5 own-message filter
+	* still suppresses them) and folding any attachment metadata into the text (so
+	* cold replay matches the live transcript's `[attached: …]` mention).
+	*/
+	async fetchThreadHistory(agentId, channel, threadTs) {
+		const conn = this.replyConnFor(agentId);
+		if (!conn?.getThreadReplies) return [];
+		const ours = new Set([conn.botUserId, conn.botId].filter(Boolean));
+		return (await conn.getThreadReplies(channel, threadTs)).map((r) => {
+			const mention = attachmentMention(r.attachments);
+			return {
+				sender: r.isBot && ours.has(r.sender) ? agentId : r.sender,
+				ts: r.ts,
+				text: mention ? `${r.text}\n${mention}`.trim() : r.text
+			};
+		});
+	}
 	queued = /* @__PURE__ */ new Map();
 	/**
 	* Handle an in-conversation control command. Resolves the target agent via the
@@ -81885,36 +82388,87 @@ var Daemon = class {
 		const statusThread = msg.thread ?? msg.msgId;
 		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…");
 		const { sessionId, blocks } = await this.sessions.handle(agentId, msg);
-		this.pending.set(sessionId, {
+		const p = {
 			conv,
 			channel: msg.channel,
 			thread: msg.thread,
-			conn: replyConn
-		});
+			statusThread,
+			conn: replyConn,
+			applyChain: Promise.resolve()
+		};
+		this.pending.set(sessionId, p);
 		try {
 			const host = await this.ensureHostAsync(agentId);
 			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
 			await host.prompt(sessionId, blocks);
-			for (const action of conv.onFinal(`local://session/${sessionId}`)) await this.applyAction(action, replyConn, msg.channel, statusThread);
+			this.clearIdle(p);
+			const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
+			for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
+			await p.applyChain;
 		} finally {
+			this.clearIdle(p);
 			this.pending.delete(sessionId);
 		}
 		this.flushQueued(agentId, sessionId, integrationId);
 	}
-	/** Route a converger action: set-status → setStatus (status + rotating loading_messages;
-	*  '' clears); else postMessage. */
-	async applyAction(action, conn, channel, thread) {
-		if (action.kind === "set-status") {
-			if (conn && thread) await conn.setStatus(channel, thread, action.text, action.loadingMessages);
-			return;
+	/**
+	* Apply one converger action against the session's Slack connection:
+	*  - set-status → assistant.threads.setStatus (best-effort; '' clears)
+	*  - post       → a new thread message
+	*  - progress / plan → the single in-place message of that kind, posted once
+	*    then chat.update-ed (§9.1 就地更新). The first post's ts is remembered on `p`.
+	*/
+	async applyAction(p, action) {
+		const conn = p.conn;
+		if (!conn) return;
+		switch (action.kind) {
+			case "set-status":
+				if (p.statusThread) await conn.setStatus(p.channel, p.statusThread, action.text, action.loadingMessages);
+				return;
+			case "post":
+				await conn.postMessage(p.channel, action.text, p.thread);
+				return;
+			case "progress":
+				if (p.progressTs) await conn.updateMessage(p.channel, p.progressTs, action.text);
+				else if (!p.progressAttempted) {
+					p.progressAttempted = true;
+					p.progressTs = await conn.postMessage(p.channel, action.text, p.thread);
+				}
+				return;
+			case "plan":
+				if (p.planTs) await conn.updateMessage(p.channel, p.planTs, action.text);
+				else if (!p.planAttempted) {
+					p.planAttempted = true;
+					p.planTs = await conn.postMessage(p.channel, action.text, p.thread);
+				}
+				return;
 		}
-		await conn?.postMessage(channel, action.text, thread);
+	}
+	/** Serialize action application per session so in-place edits never race on the
+	*  remembered message ts (two concurrent `progress` actions both posting). */
+	enqueueApply(p, action) {
+		p.applyChain = p.applyChain.then(() => this.applyAction(p, action).catch((err) => this.log.error(`slack apply failed: ${formatErr(err)}`)));
+	}
+	/** (Re)arm the ~2s idle-flush timer when body text is buffered (§9.1 text-buffer):
+	*  a long pure-text stream posts in steps instead of all at turn end. */
+	armIdle(p) {
+		this.clearIdle(p);
+		if (!p.conv.hasBuffered()) return;
+		p.idleTimer = setTimeout(() => {
+			p.idleTimer = void 0;
+			for (const action of p.conv.flushBuffered()) this.enqueueApply(p, action);
+		}, IDLE_FLUSH_MS);
+	}
+	clearIdle(p) {
+		if (p.idleTimer) clearTimeout(p.idleTimer);
+		p.idleTimer = void 0;
 	}
 	pending = /* @__PURE__ */ new Map();
 	onAcpUpdate(_agentId, sessionId, update) {
 		const p = this.pending.get(sessionId);
 		if (!p) return;
-		for (const action of p.conv.onUpdate(update)) this.applyAction(action, p.conn, p.channel, p.thread).catch((err) => console.error("slack post failed:", err));
+		for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
+		this.armIdle(p);
 	}
 	async ensureHostAsync(agentId) {
 		const host = this.ensureHost(agentId, this.cfg);
@@ -82302,7 +82856,7 @@ program.command("run").description("Run the daemon in the foreground").action(as
 	}
 });
 program.command("mcp-bridge", { hidden: true }).description("internal: stdio MCP bridge to the running daemon").action(async () => {
-	const { runBridge } = await import("./bridge-Dj8U1Jp7.js");
+	const { runBridge } = await import("./bridge-hZMpl3k6.js");
 	await runBridge();
 });
 const controller = () => resolveController({ root: program.opts().root });