@agentconnect.md/daemon 1.0.0-rc.344 → 1.0.0-rc.346

package/dist/{run-foreground-BqC40mtd.js → run-foreground-CS56Yp2s.js}

@@ -3,10 +3,10 @@ import { n as require_ms, t as require_src$3 } from "./src-DDtlVutj.js";
 import { n as init_esm_shims, t as __dirname } from "./esm-shims-DxGcm4Hw.js";
 import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
 import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseObject, i as any, m as object, o as boolean, p as number$1, t as ZodNumber, v as string, x as url$4 } from "./schemas-CQkO9hC5.js";
-import { _ as RESERVED_MCP_SERVER_NAME, a as RELAY_DAEMON_WS_PATH, c as SHARED_CONFIG_ACTION_ID, d as encode, f as MAX_FRAME_BYTES, h as HookReport, i as RELAY_DAEMON_SUBPROTOCOL, l as buildEnvelope, n as gitRepoLabel, o as buildRelayDaemonFrame, r as normalizeGitUrl, s as decodeRelayDaemonFrame, u as decodeEnvelope, v as ZodIssueCode } from "./dist-MrCr7fl1.js";
-import { a as agentChildEnv, c as persistRelays, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-BAQcjcVh.js";
+import { _ as HookReport, a as RELAY_DAEMON_WS_PATH, b as ZodIssueCode, c as SHARED_AGENT_SELECT_ACTION_ID, d as buildEnvelope, f as decodeEnvelope, i as RELAY_DAEMON_SUBPROTOCOL, l as SLACK_STATUS_ACTION, m as MAX_FRAME_BYTES, n as gitRepoLabel, o as buildRelayDaemonFrame, p as encode, r as normalizeGitUrl, s as decodeRelayDaemonFrame, u as encodeSharedSlackStatusTarget, y as RESERVED_MCP_SERVER_NAME } from "./dist-nbZ5Ymz0.js";
+import { a as agentChildEnv, c as persistRelays, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-D02wd-zM.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { C as toolsForIntegrations, E as resolveRuntimes, S as MEMORY_TOOL_NAMES, T as cachedRuntimeVersions, _ as listMemory, a as prefetchWorkspace, b as ALL_TOOL_NAMES, c as probeGitVersion, d as createMemoryProvider, f as memoryKindOf, g as MemoryTooLargeError, h as MemoryPathError, i as installedRuntimes, l as sessionGitEnv, m as MemoryConflictError, n as turnFailureCode, o as prepareWorkspace, p as memoryProviderFor, r as turnFailureReason, s as initGitInjection, t as AcpHost, u as simpleGit, v as resolveInMemoryDir, w as cachedRuntimeNames, x as GITHUB_REVIEW_TOOLS, y as writeMemoryFile } from "./acp-host-rssqAAfr.js";
+import { C as toolsForIntegrations, E as resolveRuntimes, S as MEMORY_TOOL_NAMES, T as cachedRuntimeVersions, _ as listMemory, a as prefetchWorkspace, b as ALL_TOOL_NAMES, c as probeGitVersion, d as createMemoryProvider, f as memoryKindOf, g as MemoryTooLargeError, h as MemoryPathError, i as installedRuntimes, l as sessionGitEnv, m as MemoryConflictError, n as turnFailureCode, o as prepareWorkspace, p as memoryProviderFor, r as turnFailureReason, s as initGitInjection, t as AcpHost, u as simpleGit, v as resolveInMemoryDir, w as cachedRuntimeNames, x as GITHUB_REVIEW_TOOLS, y as writeMemoryFile } from "./acp-host-cFIM27G4.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Bu-Svl7L.js";
 import { B as ToolListChangedNotificationSchema, D as ListPromptsResultSchema, E as ListChangedOptionsBaseSchema, F as PromptListChangedNotificationSchema, G as isZ4Schema, H as isJSONRPCRequest, I as ReadResourceResultSchema, J as encodeFrame, K as safeParse, L as ResourceListChangedNotificationSchema, M as ListToolsResultSchema, O as ListResourceTemplatesResultSchema, P as McpError, R as SUPPORTED_PROTOCOL_VERSIONS, S as InitializeResultSchema, T as LATEST_PROTOCOL_VERSION, U as isJSONRPCResultResponse, V as isInitializedNotification, W as getObjectShape, _ as ElicitResultSchema, a as AjvJsonSchemaValidator, b as GetPromptResultSchema, c as mergeCapabilities, d as CompleteResultSchema, f as CreateMessageRequestSchema, g as ElicitRequestSchema, h as CreateTaskResultSchema, i as assertToolsCallTaskCapability, k as ListResourcesResultSchema, m as CreateMessageResultWithToolsSchema, n as serializeMessage, o as require_fast_deep_equal, p as CreateMessageResultSchema, q as decodeFrames, r as assertClientRequestTaskCapability, s as Protocol, t as ReadBuffer, u as CallToolResultSchema, v as EmptyResultSchema, w as JSONRPCMessageSchema, y as ErrorCode } from "./stdio-DnS8WcXi.js";
 import { createRequire } from "node:module";
@@ -68195,8 +68195,10 @@ function attributionMrkdwn(info) {
 	const model = escapeMrkdwnLabel(info.model);
 	return `sent by <${info.botUrl}|${botName}> (${runtime} · ${model}) · <${info.sessionUrl}|open in session>`;
 }
-/** The classic per-turn footer is a compact secondary/gray Slack `context` block. */
-function attributionBlocks(info) {
+/** The per-turn footer is a compact secondary/gray Slack `context` block. Exported so
+*  the daemon can include it in the reply's initial chat.postMessage (the only reliable
+*  point at which Slack's unfurl controls apply). */
+function buildAttributionBlocks(info) {
 	return {
 		text: attributionText(info),
 		blocks: [{
@@ -68208,29 +68210,6 @@ function attributionBlocks(info) {
 		}]
 	};
 }
-/** The shared-bot variant uses the same text but a `section`, because only sections take
-*  the config button accessory. The click lands on the relay (it owns Socket Mode). */
-function sharedFooterBlocks(info) {
-	return {
-		text: attributionText(info),
-		blocks: [{
-			type: "section",
-			text: {
-				type: "mrkdwn",
-				text: attributionMrkdwn(info)
-			},
-			accessory: {
-				type: "button",
-				text: {
-					type: "plain_text",
-					text: "👤",
-					emoji: true
-				},
-				action_id: SHARED_CONFIG_ACTION_ID
-			}
-		}]
-	};
-}
 /** Pull human-readable output text out of an ACP tool_call/_update. Prefers the `content[]`
 *  text blocks (the tool's reported output); falls back to a string `rawOutput`. diff /
 *  terminal blocks and non-string rawOutput are skipped — they have no compact inline text. */
@@ -68288,18 +68267,9 @@ function renderStatusBar(info) {
 	if (info.totalTokens !== void 0) parts.push(`${compactCount$2(info.totalTokens)} tok`);
 	return `:bar_chart: ${parts.length ? parts.join(" · ") : "—"}`;
 }
-/** Slack action_ids for the interactive status bar + modal (matched by the connection's
-*  handlers). Kept here so the builders and the handlers can't drift apart. */
-const STATUS_ACTION = {
-	manage: "ac_manage",
-	setModel: "ac_set_model",
-	setEffort: "ac_set_effort",
-	setPermissionMode: "ac_set_permission_mode",
-	setFast: "ac_set_fast",
-	setOutput: "ac_set_output",
-	cancel: "ac_cancel",
-	view: "ac_view"
-};
+/** Slack action_ids for the interactive status bar + modal. The protocol owns the
+*  values because a shared bot receives the same actions on the relay first. */
+const STATUS_ACTION = SLACK_STATUS_ACTION;
 /** The modal view's callback_id — used if we ever handle a submit (controls apply on
 *  interaction today, so there's no submit). */
 const STATUS_MODAL_CALLBACK = "ac_status_modal";
@@ -68486,16 +68456,63 @@ function buildElicitationResolvedCard(params, decision) {
 		}
 	}];
 }
-/** Build the compact in-thread status message as one Slack row: status text with an
-*  inline View Session URL, plus one Configure accessory button. Slack sections allow
-*  only one accessory, and mrkdwn links cannot dispatch block_actions, so Cancel stays in
-*  the Configure modal rather than becoming a non-functional inline link. */
-function buildStatusBlocks(info, sessionKey, link) {
+/** Build the compact in-thread status message. Dedicated bots retain the single
+*  Configure accessory. A shared bot shows its current agent in an inline external
+*  select (the relay supplies options), followed by the session's two immediate
+*  actions: Options opens the existing controls modal and Cancel stops this turn. */
+function buildStatusBlocks(info, sessionKey, link, shared) {
+	const text = link ? `${renderStatusBar(info)}  ·  <${link}|View Session>` : renderStatusBar(info);
+	if (shared) {
+		const currentAgent = {
+			text: {
+				type: "plain_text",
+				text: clampTo$2(shared.currentAgent.name, 75) || shared.currentAgent.id
+			},
+			value: shared.currentAgent.id
+		};
+		return [{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text
+			},
+			accessory: {
+				type: "external_select",
+				action_id: SHARED_AGENT_SELECT_ACTION_ID,
+				placeholder: {
+					type: "plain_text",
+					text: "Select agent"
+				},
+				initial_option: currentAgent,
+				min_query_length: 0
+			}
+		}, {
+			type: "actions",
+			elements: [{
+				type: "button",
+				action_id: STATUS_ACTION.manage,
+				text: {
+					type: "plain_text",
+					text: "Options"
+				},
+				value: shared.sessionTarget
+			}, {
+				type: "button",
+				action_id: STATUS_ACTION.cancel,
+				text: {
+					type: "plain_text",
+					text: "Cancel"
+				},
+				style: "danger",
+				value: shared.sessionTarget
+			}]
+		}];
+	}
 	return [{
 		type: "section",
 		text: {
 			type: "mrkdwn",
-			text: link ? `${renderStatusBar(info)}  ·  <${link}|View Session>` : renderStatusBar(info)
+			text
 		},
 		accessory: {
 			type: "button",
@@ -68514,13 +68531,13 @@ function fmtCount(n) {
 }
 /**
 * Build the controls modal opened from Configure (a snapshot — Slack modals don't
-* stream). `private_metadata` carries the session key so the modal's `block_actions`
-* (model/effort/fast/output selects, Cancel) resolve the session. Blocks: the model /
+* stream). `private_metadata` carries either the direct session key or a shared-bot
+* routing target so the modal's `block_actions` resolve the session. Blocks: the model /
 * effort / fast / output selectors (each omitted when not applicable), a labeled usage
 * grid (context · tokens · cost · per-type breakdown), and Cancel + View-session (URL,
 * when `link`). The modal has room, so each metric gets its own labeled cell. Pure.
 */
-function buildStatusModal(info, sessionKey, link) {
+function buildStatusModal(info, sessionKey, link, privateMetadata = sessionKey) {
 	const blocks = [];
 	const models = info.models ?? [];
 	if (models.length > 0) {
@@ -68720,7 +68737,7 @@ function buildStatusModal(info, sessionKey, link) {
 	return {
 		type: "modal",
 		callback_id: STATUS_MODAL_CALLBACK,
-		private_metadata: sessionKey,
+		private_metadata: privateMetadata,
 		title: {
 			type: "plain_text",
 			text: "Session"
@@ -68881,7 +68898,7 @@ var OutputConverger = class {
 		};
 		const attribution = info ? [{
 			kind: "attribution",
-			...info.shared ? sharedFooterBlocks(info) : attributionBlocks(info)
+			...buildAttributionBlocks(info)
 		}] : [];
 		if (this.mode === "low") return [
 			...this.flush(),
@@ -69092,16 +69109,7 @@ var SlackConnection = class {
 			const sessionKey = action.value;
 			const triggerId = body?.trigger_id;
 			if (!sessionKey || !triggerId) return;
-			const data = this.deps.onStatusInfo?.(sessionKey);
-			if (!data) return;
-			try {
-				await this.app.client.views.open({
-					trigger_id: triggerId,
-					view: buildStatusModal(data.info, sessionKey, data.link)
-				});
-			} catch (err) {
-				this.deps.log?.debug(`slack: views.open failed: ${err.message}`);
-			}
+			await this.openStatusModal(triggerId, sessionKey);
 		});
 		this.app.action(STATUS_ACTION.setModel, async ({ ack, action, body }) => {
 			await ack();
@@ -69188,6 +69196,22 @@ var SlackConnection = class {
 		await this.app.start();
 		log?.debug("slack: app.start resolved → socket established");
 	}
+	/** Open the existing per-session controls modal. Direct bots call this from their
+	*  local Socket Mode action handler; shared bots call it after the relay forwards the
+	*  click over `rd/msg(slack_action)`. `privateMetadata` stays opaque to Slack and lets the
+	*  relay route subsequent select/cancel interactions back to this daemon. */
+	async openStatusModal(triggerId, sessionKey, privateMetadata = sessionKey) {
+		const data = this.deps.onStatusInfo?.(sessionKey);
+		if (!data) return;
+		try {
+			await this.app.client.views.open({
+				trigger_id: triggerId,
+				view: buildStatusModal(data.info, sessionKey, data.link, privateMetadata)
+			});
+		} catch (err) {
+			this.deps.log?.debug(`slack: views.open failed: ${err.message}`);
+		}
+	}
 	rememberAssistantThread(ev) {
 		const channel = ev.assistant_thread?.channel_id;
 		const threadTs = ev.assistant_thread?.thread_ts;
@@ -69235,10 +69259,17 @@ var SlackConnection = class {
 	}
 	async postMessage(channel, text, threadTs, options) {
 		return this.queue.enqueue(async () => {
+			const body = markdownBlock(text);
+			const trailing = options?.trailingBlocks;
 			return (await this.postChatMessage({
 				channel,
 				thread_ts: threadTs,
-				...markdownBlock(text)
+				...body,
+				...trailing?.length ? {
+					blocks: [...body.blocks, ...trailing],
+					unfurl_links: false,
+					unfurl_media: false
+				} : {}
 			}, options))?.ts;
 		});
 	}
@@ -69273,13 +69304,12 @@ var SlackConnection = class {
 			}, options))?.ts;
 		});
 	}
-	/** Edit a previously-posted Block Kit message in place (chat.update). Best-effort.
-	*  `unfurl_links: false` keeps an edit from unfurling console URLs. `text` is optional:
-	*  footer attachment omits it so Slack retains the original notification fallback and
-	*  a 12k markdown block cannot overflow chat.update's 4k top-level text limit. */
+	/** Edit a previously-posted Block Kit message in place (chat.update). Best-effort;
+	*  returns false after logging so footer migration can retry a failed cleanup. `text`
+	*  is optional so callers can preserve the original notification fallback. */
 	async updateBlocks(channel, ts, blocks, text) {
-		await this.queue.enqueue(async () => {
-			try {
+		try {
+			return await this.queue.enqueue(async () => {
 				await this.app.client.chat.update({
 					channel,
 					ts,
@@ -69288,10 +69318,12 @@ var SlackConnection = class {
 					unfurl_links: false,
 					unfurl_media: false
 				});
-			} catch (err) {
-				this.deps.log?.debug(`slack: chat.update (blocks) failed (ch=${channel} ts=${ts}): ${err.message}`);
-			}
-		});
+				return true;
+			});
+		} catch (err) {
+			this.deps.log?.debug(`slack: chat.update (blocks) failed (ch=${channel} ts=${ts}): ${err.message}`);
+			return false;
+		}
 	}
 	/**
 	* Pull a Slack thread's full history (conversations.replies, cursor-paginated)
@@ -217352,11 +217384,11 @@ var Daemon = class Daemon {
 	agentCallDeliveries = /* @__PURE__ */ new Map();
 	orchestrationDeadlines = /* @__PURE__ */ new Map();
 	/**
-	* Dispatch one inbound relay item (`rd/msg` — a webchat op or a hook fire) and
+	* Dispatch one inbound relay item (`rd/msg` — webchat, shared IM/action, or hook) and
 	* return the `rd/ack` verdict — the relay-path entry, reusing the SAME turn
 	* engine + by-key cores as the (retiring) CP path. The `chat` callback streams
 	* a webchat reply back as `rd/chat` over the relay socket the op arrived on
-	* (no-op for hooks — their outcome goes to the CP as `hook/report`).
+	* (no-op outside webchat; hook outcomes go to the CP as `hook/report`).
 	*
 	* Deduped by the relay-minted (sessionKey, msgId): the wire is at-least-once, so a
 	* retransmitted rd/msg (identical msgId) must NOT run the user's turn a second time —
@@ -217389,7 +217421,7 @@ var Daemon = class Daemon {
 			this.pendingRelayMsgAcks.set(dedupKey, task);
 			return task;
 		}
-		const ack = msg.source === "webchat" ? this.dispatchRelayOp(msg, chat) : this.handleRelayIm(msg);
+		const ack = msg.source === "webchat" ? this.dispatchRelayOp(msg, chat) : msg.source === "slack_action" ? this.handleRelaySlackAction(msg) : this.handleRelayIm(msg);
 		if (this.relayMsgAcks.size >= 2e3) this.relayMsgAcks.clear();
 		this.relayMsgAcks.set(dedupKey, ack);
 		return ack;
@@ -217442,6 +217474,97 @@ var Daemon = class Daemon {
 			accepted: true
 		};
 	}
+	/** Apply one shared-bot status interaction after the relay has validated the opaque
+	*  target against its live bot assignment. Re-check every daemon-owned boundary before
+	*  opening or mutating anything: the agent, shared Slack integration, local connection,
+	*  session owner, and (when retained) exact delivery binding must all still agree. */
+	handleRelaySlackAction(msg) {
+		const agent = this.agents.get(msg.agentId);
+		if (!agent) {
+			this.log.warn(`relay: Slack action for unknown agent ${msg.agentId} — dropping`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "no_agent"
+			};
+		}
+		if (!agent.integrations.find((candidate) => candidate.id === msg.integrationId && candidate.platform === "slack" && candidate.slack.mode === "shared")) {
+			this.log.warn(`relay: Slack action for non-shared integration ${msg.integrationId} on agent ${msg.agentId} — dropping`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "not_found"
+			};
+		}
+		const conn = this.connByIntegration.get(msg.integrationId);
+		if (!conn) {
+			this.log.warn(`relay: Slack action for unavailable integration ${msg.integrationId} — dropping`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "unavailable"
+			};
+		}
+		const rec = this.store.getSession(msg.sessionKey);
+		if (!rec || rec.agentId !== msg.agentId || rec.platform !== "slack") {
+			this.log.warn(`relay: Slack action for stale or foreign session ${msg.sessionKey} — dropping`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "not_found"
+			};
+		}
+		const binding = this.sessionDeliveryBindings.get(msg.sessionKey);
+		if (binding && (binding.agentId !== msg.agentId || binding.platform !== "slack" || binding.integrationId !== msg.integrationId)) {
+			this.log.warn(`relay: Slack action delivery binding mismatch for session ${msg.sessionKey} — dropping`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "stale"
+			};
+		}
+		const payload = msg.payload;
+		if (payload.kind === "open-config") {
+			const privateMetadata = encodeSharedSlackStatusTarget({
+				agentId: msg.agentId,
+				integrationId: msg.integrationId,
+				sessionKey: msg.sessionKey
+			});
+			conn.openStatusModal(payload.triggerId, msg.sessionKey, privateMetadata);
+		} else if (payload.kind === "set-model") this.handleStatusAction({
+			kind: payload.kind,
+			sessionKey: msg.sessionKey,
+			model: payload.model
+		});
+		else if (payload.kind === "set-effort") this.handleStatusAction({
+			kind: payload.kind,
+			sessionKey: msg.sessionKey,
+			effort: payload.effort
+		});
+		else if (payload.kind === "set-permission-mode") this.handleStatusAction({
+			kind: payload.kind,
+			sessionKey: msg.sessionKey,
+			permissionMode: payload.permissionMode
+		});
+		else if (payload.kind === "set-fast") this.handleStatusAction({
+			kind: payload.kind,
+			sessionKey: msg.sessionKey,
+			fastMode: payload.fastMode
+		});
+		else if (payload.kind === "set-output") this.handleStatusAction({
+			kind: payload.kind,
+			sessionKey: msg.sessionKey,
+			outputMode: payload.outputMode
+		});
+		else this.handleStatusAction({
+			kind: "cancel",
+			sessionKey: msg.sessionKey
+		});
+		return {
+			msgId: msg.msgId,
+			accepted: true
+		};
+	}
 	relayAgentMsgAcks = /* @__PURE__ */ new Map();
 	/**
 	* TARGET side of a cross-daemon `messageAgent` (agent-collaboration §2.3/§6.2, P2) —
@@ -219517,6 +219640,7 @@ var Daemon = class Daemon {
 			rec,
 			agentId,
 			agentName,
+			...integrationId !== void 0 ? { integrationId } : {},
 			...iconUrl ? { iconUrl } : {},
 			platform: msg.platform,
 			isDm: msg.isDm,
@@ -219572,6 +219696,20 @@ var Daemon = class Daemon {
 			const modelOptions = host.modelOptions?.(sessionId) ?? null;
 			const advertisedModel = modelOptions?.current;
 			const turnModel = modelOptions === null ? override ?? agent.runtimeOverrides?.model : advertisedModel === "default" ? void 0 : advertisedModel;
+			const currentSlackAttributionInfo = () => ({
+				botName: agentName,
+				botUrl: this.agentLink(agentId),
+				runtime: this.runtimeNames[agent.runtime] ?? agent.runtime,
+				model: this.buildStatusInfo(p).model ?? turnModel ?? "default",
+				sessionUrl: this.sessionLink(sessionId)
+			});
+			if (p.platform === "slack") {
+				const attribution = buildAttributionBlocks(currentSlackAttributionInfo());
+				p.attribution = {
+					blocks: attribution.blocks,
+					key: JSON.stringify(attribution.blocks)
+				};
+			}
 			if (!wasRunning) this.showActivity(replyConn, msg.channel, statusThread, "is thinking…");
 			this.emitStatusBar(p);
 			const { stopReason, usage } = await host.prompt(sessionId, blocks);
@@ -219626,14 +219764,15 @@ var Daemon = class Daemon {
 				}
 			} else {
 				const link = this.sessionLink(sessionId);
-				const finals = conv instanceof TelegramConverger || conv instanceof DiscordConverger ? conv.onFinal(link) : conv.onFinal({
-					botName: agentName,
-					botUrl: this.agentLink(agentId),
-					runtime: this.runtimeNames[agent.runtime] ?? agent.runtime,
-					model: this.buildStatusInfo(p).model ?? turnModel ?? "default",
-					sessionUrl: link,
-					shared: this.isSharedSlackIntegration(agentId, integrationId)
-				});
+				const finalSlackAttributionInfo = currentSlackAttributionInfo();
+				if (p.platform === "slack") {
+					const attribution = buildAttributionBlocks(finalSlackAttributionInfo);
+					p.attribution = {
+						blocks: attribution.blocks,
+						key: JSON.stringify(attribution.blocks)
+					};
+				}
+				const finals = conv instanceof TelegramConverger || conv instanceof DiscordConverger ? conv.onFinal(link) : conv.onFinal(finalSlackAttributionInfo);
 				for (const action of finals) this.enqueueApply(p, action);
 			}
 			for (const ev of rec.onFinal()) this.recordEvent(agentId, msg.channel, statusThread, ev);
@@ -219679,7 +219818,8 @@ var Daemon = class Daemon {
 				}
 				if (!covered) this.enqueueApply(p, {
 					kind: "post",
-					text: `⚠️ Agent failed to respond: ${reason}`
+					text: `⚠️ Agent failed to respond: ${reason}`,
+					attributed: false
 				});
 				this.showActivity(replyConn, msg.channel, statusThread, "");
 				await p.applyChain;
@@ -219692,6 +219832,7 @@ var Daemon = class Daemon {
 		} finally {
 			this.clearCancelBackstop(agentId, sessionId);
 			if (p.outputSuppressed) await p.applyChain.catch(() => {});
+			if (p.platform === "slack" && p.conn && p.staleReplyFooters?.length) await this.clearStaleSlackReplyFooters(p.conn, p);
 			releaseReplyConn();
 			this.clearIdle(p);
 			this.releasePermissions(agentId, sessionId);
@@ -219873,11 +220014,11 @@ var Daemon = class Daemon {
 	* Apply one converger action against the session's Slack connection:
 	*  - set-status → assistant.threads.setStatus (best-effort; '' clears)
 	*  - set-title  → assistant.threads.setTitle (best-effort; app DMs only)
-	*  - post       → a new thread message; ALSO recorded to the transcript as the
-	*    agent's reply text (sender = agentId), so other agents replaying the thread
-	*    see what it said. Keyed on `statusThread` (the §8.5 replay key).
+	*  - post       → a new thread message born with the linked footer; ALSO recorded
+	*    to the transcript as the agent's reply text (sender = agentId), so other agents
+	*    replaying the thread see what it said. Keyed on `statusThread` (§8.5).
 	*  - notice     → posted to the thread but NOT recorded (system chrome).
-	*  - attribution → folds trailing footer blocks into the last successful `post`.
+	*  - attribution → closes the footer lifecycle and retries stale-section cleanup.
 	*  - 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`.
 	*/
@@ -219888,6 +220029,25 @@ var Daemon = class Daemon {
 			...p.iconUrl ? { icon_url: p.iconUrl } : {}
 		};
 	}
+	/** Remove attribution blocks from older body sections. Slack edits are best-effort,
+	*  so retain failed rows for the next body post and the finalization retry. Test fakes
+	*  historically return void; only an explicit `false` means the update failed. */
+	async clearStaleSlackReplyFooters(conn, p, additional = []) {
+		const pending = [...p.staleReplyFooters ?? [], ...additional];
+		if (pending.length === 0) return;
+		delete p.staleReplyFooters;
+		const failed = [];
+		for (const reply of new Map(pending.map((item) => [item.ts, item])).values()) try {
+			if (await conn.updateBlocks(p.channel, reply.ts, [{
+				type: "markdown",
+				text: reply.text
+			}]) === false) failed.push(reply);
+		} catch (err) {
+			failed.push(reply);
+			this.log.debug(`slack: stale footer cleanup failed (${reply.ts}): ${formatErr(err)}`);
+		}
+		if (failed.length > 0) p.staleReplyFooters = failed;
+	}
 	async applySlackAction(p, action) {
 		const conn = p.conn;
 		if (!conn) {
@@ -219910,11 +220070,25 @@ var Daemon = class Daemon {
 				if (p.statusThread) await conn.setTitle(p.channel, p.statusThread, action.text);
 				return;
 			case "post": {
-				const ts = await conn.postMessage(p.channel, action.text, p.thread, postOptions);
-				if (ts) p.lastReply = {
-					ts,
-					text: action.text
-				};
+				const trackReply = action.attributed !== false;
+				const previous = trackReply ? p.lastReply : void 0;
+				const attribution = trackReply ? p.attribution : void 0;
+				const replyOptions = attribution ? {
+					...postOptions,
+					trailingBlocks: attribution.blocks
+				} : postOptions;
+				const ts = await conn.postMessage(p.channel, action.text, p.thread, replyOptions);
+				if (ts && trackReply) {
+					if (attribution) await this.clearStaleSlackReplyFooters(conn, p, previous?.footerKey ? [{
+						ts: previous.ts,
+						text: previous.text
+					}] : []);
+					p.lastReply = {
+						ts,
+						text: action.text,
+						...attribution ? { footerKey: attribution.key } : {}
+					};
+				}
 				this.store.appendTranscript({
 					channel: p.channel,
 					thread: p.statusThread,
@@ -219930,10 +220104,11 @@ var Daemon = class Daemon {
 				await conn.postMessage(p.channel, action.text, p.thread, postOptions);
 				return;
 			case "attribution":
-				if (p.lastReply) await conn.updateBlocks(p.channel, p.lastReply.ts, [{
-					type: "markdown",
-					text: p.lastReply.text
-				}, ...action.blocks]);
+				p.attribution = {
+					blocks: action.blocks,
+					key: JSON.stringify(action.blocks)
+				};
+				await this.clearStaleSlackReplyFooters(conn, p);
 				return;
 			case "progress":
 				if (p.progressTs) await conn.updateMessage(p.channel, p.progressTs, action.text);
@@ -219970,7 +220145,8 @@ var Daemon = class Daemon {
 					await conn.updateBlocks(p.channel, ts, action.blocks, action.text);
 				} else if (!p.statusBarAttempted) {
 					p.statusBarAttempted = true;
-					const posted = await conn.postBlocks(p.channel, action.blocks, action.text, p.thread, postOptions);
+					const statusPostOptions = this.isSharedSlackIntegration(p.agentId, p.integrationId) ? void 0 : postOptions;
+					const posted = await conn.postBlocks(p.channel, action.blocks, action.text, p.thread, statusPostOptions);
 					if (posted) {
 						p.statusBarTs = posted;
 						this.store.setStatusBarTs(p.sessionKey, posted);
@@ -220144,15 +220320,14 @@ var Daemon = class Daemon {
 		const orgSeg = this.cpOrgSlug ? `/${encodeURIComponent(this.cpOrgSlug)}` : "";
 		return `${this.webAppBase()}${orgSeg}/sessions/${encodeURIComponent(acpSessionId)}`;
 	}
-	/** The console deep link to an agent: `<base>/<orgSlug>/agents/<agentId>` — the
-	*  shared-bot footer's "sent by <agent_name>" link (§10.1). Same org-seg rule as
-	*  {@link sessionLink}. */
+	/** The console deep link to an agent: `<base>/<orgSlug>/agents/<agentId>`. Same
+	*  org-segment rule as {@link sessionLink}. */
 	agentLink(agentId) {
 		const orgSeg = this.cpOrgSlug ? `/${encodeURIComponent(this.cpOrgSlug)}` : "";
 		return `${this.webAppBase()}${orgSeg}/agents/${encodeURIComponent(agentId)}`;
 	}
-	/** Whether this turn used a shared Slack integration. Shared mode renders the same
-	*  dynamic footer text in a section so it can retain the config-button accessory. */
+	/** Whether this turn's reply rides a shared Slack integration. The relay owns that
+	*  app's Socket Mode connection, so interactive actions must use relay-recognized ids. */
 	isSharedSlackIntegration(agentId, integrationId) {
 		if (!integrationId) return false;
 		const int = this.agents.get(agentId)?.integrations.find((i) => i.id === integrationId);
@@ -220311,10 +220486,21 @@ var Daemon = class Daemon {
 		else {
 			p.lastStatusBar = key;
 			const link = this.sessionLink(p.acpSessionId);
+			const shared = p.integrationId && this.isSharedSlackIntegration(p.agentId, p.integrationId) ? {
+				sessionTarget: encodeSharedSlackStatusTarget({
+					agentId: p.agentId,
+					integrationId: p.integrationId,
+					sessionKey: p.sessionKey
+				}),
+				currentAgent: {
+					id: p.agentId,
+					name: p.agentName
+				}
+			} : void 0;
 			this.enqueueApply(p, {
 				kind: "status-bar",
 				text: renderStatusBar(info),
-				blocks: buildStatusBlocks(info, p.sessionKey, link)
+				blocks: buildStatusBlocks(info, p.sessionKey, link, shared)
 			});
 		}
 	}
@@ -221846,4 +222032,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as i, CP_SUBPROTOCOL as n, CP_WS_PATH as r, runForeground as t };
 
-//# sourceMappingURL=run-foreground-BqC40mtd.js.map
+//# sourceMappingURL=run-foreground-CS56Yp2s.js.map