@agentconnect.md/daemon 1.0.0-rc.157 → 1.0.0-rc.158

package/dist/index.js

@@ -12852,6 +12852,7 @@ const AuthOk = object({
 	sessionEpoch: number().int(),
 	heartbeatSec: number().int(),
 	serverTime: string().datetime(),
+	webAppUrl: string().optional(),
 	resume: object({ accepted: boolean() }).optional()
 });
 //#endregion
@@ -13618,6 +13619,18 @@ const WebchatEvent = discriminatedUnion("kind", [
 		title: string()
 	})
 ]);
+const WebchatStatus = object({
+	model: string().optional(),
+	effort: string().optional(),
+	fastMode: boolean().optional(),
+	contextUsed: number().int().optional(),
+	contextSize: number().int().optional(),
+	totalTokens: number().int().optional(),
+	costAmount: number().optional(),
+	costCurrency: string().optional(),
+	models: array(string()).optional(),
+	sessionId: string().optional()
+});
 //#endregion
 //#region ../protocol/dist/frame.js
 /**
@@ -13650,8 +13663,9 @@ const FRAME_SCHEMAS = {
 		conversationId: string().uuid(),
 		turnId: string().uuid(),
 		index: number().int(),
-		event: WebchatEvent
-	}),
+		event: WebchatEvent.optional(),
+		status: WebchatStatus.optional()
+	}).refine((o) => o.event !== void 0 || o.status !== void 0, { message: "WebchatOutput must carry event and/or status" }),
 	"webchat/done": object({
 		conversationId: string().uuid(),
 		turnId: string().uuid(),
@@ -13663,6 +13677,12 @@ const FRAME_SCHEMAS = {
 		error: string().optional()
 	}),
 	"webchat/close": object({ conversationId: string().uuid() }),
+	"webchat/set-model": object({
+		conversationId: string().uuid(),
+		agentId: string().uuid(),
+		model: string()
+	}),
+	"webchat/cancel": object({ conversationId: string().uuid() }),
 	"route/assign": RouteAssign,
 	"route/assign/ack": RouteAssignAck,
 	"route/update": RouteUpdate,
@@ -13739,6 +13759,8 @@ discriminatedUnion("type", [
 	frame("webchat/output", FRAME_SCHEMAS["webchat/output"]),
 	frame("webchat/done", FRAME_SCHEMAS["webchat/done"]),
 	frame("webchat/close", FRAME_SCHEMAS["webchat/close"]),
+	frame("webchat/set-model", FRAME_SCHEMAS["webchat/set-model"]),
+	frame("webchat/cancel", FRAME_SCHEMAS["webchat/cancel"]),
 	frame("route/assign", FRAME_SCHEMAS["route/assign"]),
 	frame("route/assign/ack", FRAME_SCHEMAS["route/assign/ack"]),
 	frame("route/update", FRAME_SCHEMAS["route/update"]),
@@ -18213,6 +18235,7 @@ var AcpHost = class {
 	canLoad = false;
 	promptCaps = {};
 	lastModelOptions = null;
+	sessionConfigs = /* @__PURE__ */ new Map();
 	negotiatedProtocolVersion;
 	constructor(runtime, opts) {
 		this.runtime = runtime;
@@ -18286,6 +18309,7 @@ var AcpHost = class {
 		this.live.add(res.sessionId);
 		const configOptions = await this.applySessionConfig(res.sessionId, res.configOptions);
 		this.lastModelOptions = modelOptionsFrom(configOptions);
+		this.sessionConfigs.set(res.sessionId, configOptions);
 		return res.sessionId;
 	}
 	/**
@@ -18331,6 +18355,30 @@ var AcpHost = class {
 	modelOptions() {
 		return this.lastModelOptions;
 	}
+	/**
+	* Switch the model of an ALREADY-RUNNING session via ACP `session/set_config_option`
+	* (category `model`) — the mid-session counterpart of the model applied at
+	* new/load. Returns true iff the change was applied: false when the session isn't
+	* live here, the runtime advertises no model selector, the value isn't offered, or
+	* it's already selected. Refreshes the cached options + `lastModelOptions` on success.
+	*/
+	async setSessionModel(sessionId, model) {
+		if (!this.live.has(sessionId)) return false;
+		const plan = planConfigSelection(this.sessionConfigs.get(sessionId), "model", model);
+		if ("skip" in plan) {
+			this.opts.log?.debug(`acp: setSessionModel "${model}" on ${sessionId} not applied — ${plan.skip}`);
+			return false;
+		}
+		const res = await this.conn.agent.request(methods.agent.session.setConfigOption, {
+			sessionId,
+			configId: plan.configId,
+			value: plan.value
+		});
+		this.sessionConfigs.set(sessionId, res.configOptions);
+		this.lastModelOptions = modelOptionsFrom(res.configOptions);
+		this.opts.log?.info(`acp: session ${sessionId} model set to "${model}"`);
+		return true;
+	}
 	/** The ACP protocol version negotiated at initialize, or undefined before the
 	*  handshake completed. Used by the runtime probe to report ACP coverage. */
 	acpProtocolVersion() {
@@ -18359,7 +18407,9 @@ var AcpHost = class {
 				..._meta ? { _meta } : {}
 			});
 			this.live.add(sessionId);
-			await this.applySessionConfig(sessionId, res.configOptions);
+			const configOptions = await this.applySessionConfig(sessionId, res.configOptions);
+			this.lastModelOptions = modelOptionsFrom(configOptions);
+			this.sessionConfigs.set(sessionId, configOptions);
 			this.opts.log?.info(`acp: resumed session ${sessionId} via session/load`);
 		} catch (err) {
 			this.opts.log?.debug(`acp: session/load failed for ${sessionId} (${err.message}) — will recreate`);
@@ -24123,7 +24173,7 @@ var LocalStore = class {
       CREATE TABLE IF NOT EXISTS sessions (
         key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
         acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER,
-        usage TEXT, muted INTEGER, triggeredBy TEXT, title TEXT
+        usage TEXT, muted INTEGER, triggeredBy TEXT, title TEXT, modelOverride TEXT
       );
       -- Platform id → human display name (Slack channel/user names, daemon-resolved
       -- and cached here so session read-back can label ids without a Slack call).
@@ -24169,16 +24219,17 @@ var LocalStore = class {
          ON transcript (channel, thread, tool_call_id) WHERE tool_call_id IS NOT NULL`);
 	}
 	/** Add the `sessions.usage` (JSON token accounting), `sessions.muted` (`!stop`
-	*  thread mute), `sessions.triggeredBy` and `sessions.title` columns to a
-	*  pre-existing DB. CREATE TABLE IF NOT EXISTS above adds them for fresh DBs but
-	*  never alters an existing table, so upgrade in place. No-op once the columns
-	*  are present. */
+	*  thread mute), `sessions.triggeredBy`, `sessions.title` and `sessions.modelOverride`
+	*  (the sticky per-session model choice) columns to a pre-existing DB. CREATE TABLE IF
+	*  NOT EXISTS above adds them for fresh DBs but never alters an existing table, so
+	*  upgrade in place. No-op once the columns are present. */
 	migrateSessionUsage() {
 		const cols = this.db.prepare("PRAGMA table_info(sessions)").all();
 		if (!cols.some((c) => c.name === "usage")) this.db.exec("ALTER TABLE sessions ADD COLUMN usage TEXT");
 		if (!cols.some((c) => c.name === "muted")) this.db.exec("ALTER TABLE sessions ADD COLUMN muted INTEGER");
 		if (!cols.some((c) => c.name === "triggeredBy")) this.db.exec("ALTER TABLE sessions ADD COLUMN triggeredBy TEXT");
 		if (!cols.some((c) => c.name === "title")) this.db.exec("ALTER TABLE sessions ADD COLUMN title TEXT");
+		if (!cols.some((c) => c.name === "modelOverride")) this.db.exec("ALTER TABLE sessions ADD COLUMN modelOverride TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -24266,6 +24317,16 @@ var LocalStore = class {
 	isSessionMuted(key) {
 		return this.db.prepare("SELECT muted FROM sessions WHERE key = ?").get(key)?.muted === 1;
 	}
+	/** The session-scoped model override (set via the console's in-session model switch),
+	*  or undefined if the session runs on the agent's default. Sticky across turns and
+	*  restarts, re-applied to the ACP session on each dispatch. */
+	getModelOverride(key) {
+		return this.db.prepare("SELECT modelOverride FROM sessions WHERE key = ?").get(key)?.modelOverride ?? void 0;
+	}
+	/** Persist the session-scoped model override. No-op on an unknown key. */
+	setModelOverride(key, model) {
+		this.db.prepare("UPDATE sessions SET modelOverride = ? WHERE key = ?").run(model, key);
+	}
 	/** Current token accounting for a session (parsed from the `usage` JSON column),
 	*  or `{}` if none has been recorded / the JSON is unreadable. */
 	getUsage(key) {
@@ -25157,7 +25218,8 @@ function routeRules(msg, rules, threadOwner, explicitAgentId) {
 //#region src/commands/commands.ts
 /** Accepted command prefixes (Slack uses `!`; `/` is for future platforms). */
 const COMMAND_PREFIXES = ["!", "/"];
-const STOP_WORDS = /* @__PURE__ */ new Set(["stop", "cancel"]);
+const STOP_WORDS = /* @__PURE__ */ new Set(["stop"]);
+const CANCEL_WORDS = /* @__PURE__ */ new Set(["cancel"]);
 const QUEUE_WORDS = /* @__PURE__ */ new Set(["queue"]);
 /**
 * Parse a leading control command from a message's text. Returns `null` when the
@@ -25175,6 +25237,7 @@ function parseCommand(raw) {
 	const word = m[1].toLowerCase();
 	const arg = (m[2] ?? "").trim();
 	if (STOP_WORDS.has(word)) return { kind: "stop" };
+	if (CANCEL_WORDS.has(word)) return { kind: "cancel" };
 	if (QUEUE_WORDS.has(word)) return {
 		kind: "queue",
 		text: arg
@@ -81220,6 +81283,450 @@ var SlackSendQueue = class {
 	}
 };
 //#endregion
+//#region src/slack/formatter.ts
+/**
+* Last-mile Slack formatting (§9.1 / §9.3). One pure helper:
+*  - splitIntoSections: break a message into <= maxLen sections.
+*
+* The daemon posts the agent's reply as a Block Kit `markdown` block (which renders
+* standard CommonMark natively), so NO markdown→mrkdwn conversion happens here — the
+* agent's text is sent verbatim. We only chunk it: a single `markdown` block caps at
+* 12000 chars, so a long body is split across blocks/messages on line boundaries.
+*/
+/** Slack `markdown` block hard cap (12000 chars per block). */
+const SLACK_MARKDOWN_BLOCK_LIMIT = 12e3;
+/**
+* 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_MARKDOWN_BLOCK_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;
+const MAX_LABEL = 100;
+const MAX_STATUS = 50;
+const MAX_REASONING = 2800;
+function clampTo(s, max) {
+	const t = s.trim();
+	return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+function clampLabel(s) {
+	return clampTo(s, MAX_LABEL);
+}
+/** Wrap tool activity (a command line, tool title, or tool output) in a CommonMark code
+*  span so it renders monospace and verbatim — Slack posts these as `markdown` blocks, so
+*  unwrapped text with `*` / `_` / `#` would otherwise be interpreted as emphasis. A
+*  single-line value uses an inline span, multi-line (or `block`-forced) a fenced block;
+*  the delimiter is grown past the longest internal backtick run so values containing
+*  backticks stay intact (CommonMark's variable-length fence rule). */
+function codeSpan(s, block = false) {
+	const text = s.trim();
+	if (!text) return "";
+	const longestRun = Math.max(0, ...[...text.matchAll(/`+/g)].map((m) => m[0].length));
+	if (block || text.includes("\n")) {
+		const fence = "`".repeat(Math.max(3, longestRun + 1));
+		return `${fence}\n${text}\n${fence}`;
+	}
+	const ticks = "`".repeat(longestRun + 1);
+	const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+	return `${ticks}${pad}${text}${pad}${ticks}`;
+}
+const MAX_TOOL_OUTPUT = 2800;
+function capOutput(s) {
+	const t = s.trim();
+	return t.length > MAX_TOOL_OUTPUT ? `${t.slice(0, MAX_TOOL_OUTPUT - 1)}…` : t;
+}
+/** 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. */
+function extractToolOutput(update) {
+	const content = update.content;
+	if (Array.isArray(content)) {
+		const parts = [];
+		for (const item of content) {
+			if (!item || typeof item !== "object") continue;
+			if (item.type !== "content") continue;
+			const block = item.content;
+			if (block?.type === "text" && block.text) parts.push(block.text);
+		}
+		if (parts.length) return parts.join("\n").trim();
+	}
+	return typeof update.rawOutput === "string" ? update.rawOutput.trim() : "";
+}
+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.
+*  Posted as a `markdown` block, so emphasis is CommonMark (`**bold**`), not mrkdwn. */
+function renderPlan(entries) {
+	return [":clipboard: **Plan**", ...entries.map((e) => `${planIcon(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
+}
+/** Render the accumulated reasoning trace (high mode) as one in-place message. Posted as
+*  a `markdown` block (verbatim CommonMark, so `**bold**`), tail-clamped to a compact cap
+*  — the newest thinking is the most relevant, so keep the end and mark truncation with a
+*  leading ellipsis. */
+function renderReasoning(buf) {
+	const trimmed = buf.trim();
+	return `:thought_balloon: **Thinking**\n${trimmed.length > MAX_REASONING ? `…${trimmed.slice(-2800)}` : trimmed}`;
+}
+/** Compact a token count as `1.2k` / `3.4M` (whole numbers under 1000 stay verbatim). */
+function compactCount(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+}
+/** Render the session status line as one compact `markdown` block — e.g.
+*  `:bar_chart: *opus-4.8* · xhigh · fast · ctx 120k/200k (60%) · 45.2k tok · $0.18`.
+*  Pure: unknown fields are dropped so a partial snapshot still yields a clean line, and
+*  an empty snapshot degrades to a bare `:bar_chart: —` placeholder. */
+function renderStatusBar(info) {
+	const parts = [];
+	if (info.model) parts.push(`*${info.model}*`);
+	if (info.effort) parts.push(info.effort);
+	if (info.fastMode) parts.push("fast");
+	if (info.contextUsed !== void 0 && info.contextSize !== void 0 && info.contextSize > 0) {
+		const pct = Math.round(info.contextUsed / info.contextSize * 100);
+		parts.push(`ctx ${compactCount(info.contextUsed)}/${compactCount(info.contextSize)} (${pct}%)`);
+	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount(info.contextUsed)}`);
+	if (info.totalTokens !== void 0) parts.push(`${compactCount(info.totalTokens)} tok`);
+	if (info.costAmount !== void 0) {
+		const cur = info.costCurrency && info.costCurrency !== "USD" ? ` ${info.costCurrency}` : "";
+		const sym = !info.costCurrency || info.costCurrency === "USD" ? "$" : "";
+		parts.push(`${sym}${info.costAmount.toFixed(info.costAmount < 1 ? 3 : 2)}${cur}`);
+	}
+	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",
+	cancel: "ac_cancel",
+	view: "ac_view"
+};
+/** 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";
+/**
+* Build the COMPACT in-thread status message as ONE row: a `section` whose mrkdwn text is
+* the live status line (model · ctx · tokens · cost, updated via chat.update) with a
+* `View session` link appended when a `link` is known, and whose `accessory` is the ⚙
+* Manage button (opens the controls modal). Section text + one accessory share a row, so
+* status + View link + Manage all sit on one line. The session key rides the button
+* `value`. Pure — safe to unit-test.
+*/
+function buildStatusBlocks(info, sessionKey, link) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: link ? `${renderStatusBar(info)}  ·  <${link}|View session>` : renderStatusBar(info)
+		},
+		accessory: {
+			type: "button",
+			action_id: STATUS_ACTION.manage,
+			text: {
+				type: "plain_text",
+				text: ":gear: Manage",
+				emoji: true
+			},
+			value: sessionKey
+		}
+	}];
+}
+/** One `Label: value` field line for the modal's usage detail (omitted when absent). */
+function usageField(label, n) {
+	return n === void 0 ? void 0 : `*${label}:* ${n.toLocaleString("en-US")}`;
+}
+/**
+* Build the controls modal opened from the ⚙ button (a snapshot — Slack modals don't
+* stream). `private_metadata` carries the session key so the modal's `block_actions`
+* (model select / Cancel) resolve the session. Blocks: the model `static_select` (omitted
+* when no models are advertised), a usage-detail section (input/output/cache/thought
+* tokens · context · cost), and Cancel + View-session (URL, when `link`). Pure.
+*/
+function buildStatusModal(info, sessionKey, link) {
+	const blocks = [];
+	const models = info.models ?? [];
+	if (models.length > 0) {
+		const opts = info.model && !models.includes(info.model) ? [info.model, ...models] : models;
+		const option = (m) => ({
+			text: {
+				type: "plain_text",
+				text: clampTo(m, 75)
+			},
+			value: m
+		});
+		blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Model*"
+			},
+			accessory: {
+				type: "static_select",
+				action_id: STATUS_ACTION.setModel,
+				placeholder: {
+					type: "plain_text",
+					text: "Model"
+				},
+				...info.model ? { initial_option: option(info.model) } : {},
+				options: opts.map(option)
+			}
+		});
+	} else if (info.model) blocks.push({
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Model:* ${info.model}`
+		}
+	});
+	const detail = [
+		renderStatusBar({
+			...info,
+			model: void 0
+		}),
+		usageField("Input", info.inputTokens),
+		usageField("Output", info.outputTokens),
+		usageField("Thought", info.thoughtTokens),
+		usageField("Cache read", info.cachedReadTokens),
+		usageField("Cache write", info.cachedWriteTokens)
+	].filter(Boolean);
+	blocks.push({
+		type: "context",
+		elements: [{
+			type: "mrkdwn",
+			text: detail.join("  ·  ")
+		}]
+	});
+	const actions = [{
+		type: "button",
+		action_id: STATUS_ACTION.cancel,
+		text: {
+			type: "plain_text",
+			text: "Cancel turn"
+		},
+		style: "danger",
+		value: sessionKey
+	}];
+	if (link) actions.push({
+		type: "button",
+		action_id: STATUS_ACTION.view,
+		text: {
+			type: "plain_text",
+			text: "View session"
+		},
+		url: link
+	});
+	blocks.push({
+		type: "actions",
+		elements: actions
+	});
+	return {
+		type: "modal",
+		callback_id: STATUS_MODAL_CALLBACK,
+		private_metadata: sessionKey,
+		title: {
+			type: "plain_text",
+			text: "Session"
+		},
+		close: {
+			type: "plain_text",
+			text: "Close"
+		},
+		blocks
+	};
+}
+var OutputConverger = class {
+	mode;
+	buf = "";
+	reasoningBuf = "";
+	reasoningDirty = false;
+	activity = [];
+	toolTitles = /* @__PURE__ */ new Map();
+	toolOutputs = /* @__PURE__ */ new Map();
+	emittedOutput = /* @__PURE__ */ new Set();
+	constructor(mode) {
+		this.mode = mode;
+	}
+	/** True while body text OR reasoning is pending — 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 and streamed thinking updates its in-place block at most once per window. */
+	hasBuffered() {
+		return this.buf.trim().length > 0 || this.reasoningDirty;
+	}
+	/** Flush pending output for the idle timer: in high mode one in-place `reasoning` update
+	*  carrying the reasoning accumulated since the last flush, THEN the buffered body
+	*  (verbatim markdown split into ≤block-limit `post` sections — each a Block Kit
+	*  `markdown` block, no mrkdwn conversion). Reasoning is emitted first so its in-place
+	*  block is first-posted ABOVE the reply: thinking precedes the answer (§9.1), so the
+	*  Thinking block must sit above it, not below. */
+	flushBuffered() {
+		return [...this.drainReasoning(), ...this.flush()];
+	}
+	/** Drain reasoning buffered since the last flush into a 0-or-1-length action list (only
+	*  high mode ever sets `reasoningDirty`). Callers place it before the body flush so the
+	*  Thinking block posts above the reply. */
+	drainReasoning() {
+		if (!this.reasoningDirty) return [];
+		this.reasoningDirty = false;
+		return [{
+			kind: "reasoning",
+			text: renderReasoning(this.reasoningBuf)
+		}];
+	}
+	flush() {
+		const text = this.buf;
+		this.buf = "";
+		if (!text.trim()) return [];
+		return splitIntoSections(text).map((t) => ({
+			kind: "post",
+			text: t
+		}));
+	}
+	/**
+	* Record an activity label and build the loading-status action carrying the rolling
+	* window as `loading_messages`. Consecutive repeats collapse to nothing (returns []),
+	* which throttles streamed thought chunks down to one status update per thinking run.
+	*/
+	pushActivity(raw) {
+		const label = clampTo(raw, MAX_STATUS);
+		if (this.activity[this.activity.length - 1] === label) return [];
+		this.activity.push(label);
+		if (this.activity.length > MAX_ACTIVITY) this.activity.shift();
+		return [{
+			kind: "set-status",
+			text: label,
+			loadingMessages: [...this.activity]
+		}];
+	}
+	/** Resolve a tool call's display label, reusing a known title when an update omits it. */
+	toolLabel(update) {
+		const id = update.toolCallId;
+		if (update.title) {
+			if (id) this.toolTitles.set(id, update.title);
+			return update.title;
+		}
+		return (id && this.toolTitles.get(id)) ?? id ?? "tool";
+	}
+	/** high mode: surface a finished tool's output as a code-block `tool-output` action.
+	*  Tracks the latest output across streamed updates and emits it exactly once, when the
+	*  call reaches a terminal status (completed/failed) — so partial output isn't posted
+	*  early and the final result isn't re-posted. Returns [] when there's nothing to post. */
+	drainToolOutput(update) {
+		const id = update.toolCallId;
+		if (!id) return [];
+		if (update.content !== void 0 || update.rawOutput !== void 0) {
+			const out = extractToolOutput(update);
+			if (out) this.toolOutputs.set(id, out);
+			else this.toolOutputs.delete(id);
+		}
+		if (!(update.status === "completed" || update.status === "failed") || this.emittedOutput.has(id)) return [];
+		const text = this.toolOutputs.get(id);
+		if (!text) return [];
+		this.emittedOutput.add(id);
+		this.toolOutputs.delete(id);
+		return [{
+			kind: "tool-output",
+			text: `${update.status === "failed" ? ":x:" : ":page_facing_up:"}\n${codeSpan(capOutput(text), true)}`
+		}];
+	}
+	onUpdate(update) {
+		switch (update.sessionUpdate) {
+			case "agent_message_chunk": {
+				const content = update.content;
+				if (content?.type === "text") this.buf += content.text ?? "";
+				return [];
+			}
+			case "agent_thought_chunk":
+				if (this.mode === "high") {
+					const text = update.content?.text ?? "";
+					if (text) {
+						this.reasoningBuf += text;
+						if (this.reasoningBuf.length > MAX_REASONING * 2) this.reasoningBuf = this.reasoningBuf.slice(-2800 * 2);
+						this.reasoningDirty = true;
+					}
+				}
+				return [...this.flush(), ...this.pushActivity(THINKING)];
+			case "tool_call":
+			case "tool_call_update": {
+				const u = update;
+				const label = this.toolLabel(u);
+				const status = this.pushActivity(label);
+				if (this.mode === "low") return [...this.flush(), ...status];
+				const actions = [
+					...this.flush(),
+					...status,
+					{
+						kind: "progress",
+						text: `:hammer_and_wrench: ${codeSpan(label)}`
+					}
+				];
+				if (this.mode === "high") actions.push(...this.drainToolOutput(u));
+				return actions;
+			}
+			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 reasoning = this.drainReasoning();
+		const footer = link ? [{
+			kind: "notice",
+			text: `:white_check_mark: done — [details](${link})`
+		}] : [];
+		return [
+			...reasoning,
+			...this.flush(),
+			clear,
+			...footer
+		];
+	}
+};
+//#endregion
 //#region src/slack/connection.ts
 const { App, LogLevel } = import_dist.default;
 /** §6.1: one Slack Socket Mode connection per unique appToken. */
@@ -81324,6 +81831,43 @@ var SlackConnection = class {
 			log?.debug(`slack: bot left channel ${event.channel ?? "?"} (${type})`);
 			this.deps.onChannelsChanged?.();
 		});
+		this.app.action(STATUS_ACTION.manage, async ({ ack, action, body }) => {
+			await ack();
+			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}`);
+			}
+		});
+		this.app.action(STATUS_ACTION.setModel, async ({ ack, action, body }) => {
+			await ack();
+			const sessionKey = body?.view?.private_metadata ?? action.block_id;
+			const model = action.selected_option?.value;
+			if (sessionKey && model) this.deps.onStatusAction?.({
+				kind: "set-model",
+				sessionKey,
+				model
+			});
+		});
+		this.app.action(STATUS_ACTION.cancel, async ({ ack, action, body }) => {
+			await ack();
+			const sessionKey = body?.view?.private_metadata ?? action.value;
+			if (sessionKey) this.deps.onStatusAction?.({
+				kind: "cancel",
+				sessionKey
+			});
+		});
+		this.app.action(STATUS_ACTION.view, async ({ ack }) => {
+			await ack();
+		});
 		log?.debug("slack: app.start → opening Socket Mode WebSocket (wss://…slack.com)…");
 		await this.app.start();
 		log?.debug("slack: app.start resolved → socket established");
@@ -81352,6 +81896,40 @@ var SlackConnection = class {
 			}
 		});
 	}
+	/** Post an explicit Block Kit message (the interactive status bar) — `text` is the
+	*  notification/accessibility fallback. `unfurl_links`/`unfurl_media` are off so the
+	*  status bar's "View session" URL doesn't sprout a link-preview card. Returns the ts
+	*  for later in-place edits. */
+	async postBlocks(channel, blocks, text, threadTs) {
+		return this.queue.enqueue(async () => {
+			return (await this.app.client.chat.postMessage({
+				channel,
+				thread_ts: threadTs,
+				text,
+				blocks,
+				unfurl_links: false,
+				unfurl_media: false
+			}))?.ts;
+		});
+	}
+	/** Edit a previously-posted Block Kit message in place (chat.update). Best-effort.
+	*  `unfurl_links: false` keeps an edit from unfurling the "View session" URL. */
+	async updateBlocks(channel, ts, blocks, text) {
+		await this.queue.enqueue(async () => {
+			try {
+				await this.app.client.chat.update({
+					channel,
+					ts,
+					text,
+					blocks,
+					unfurl_links: false,
+					unfurl_media: false
+				});
+			} catch (err) {
+				this.deps.log?.debug(`slack: chat.update (blocks) 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;
@@ -81621,282 +82199,6 @@ var SlackNameResolver = class {
 	}
 };
 //#endregion
-//#region src/slack/formatter.ts
-/**
-* Last-mile Slack formatting (§9.1 / §9.3). One pure helper:
-*  - splitIntoSections: break a message into <= maxLen sections.
-*
-* The daemon posts the agent's reply as a Block Kit `markdown` block (which renders
-* standard CommonMark natively), so NO markdown→mrkdwn conversion happens here — the
-* agent's text is sent verbatim. We only chunk it: a single `markdown` block caps at
-* 12000 chars, so a long body is split across blocks/messages on line boundaries.
-*/
-/** Slack `markdown` block hard cap (12000 chars per block). */
-const SLACK_MARKDOWN_BLOCK_LIMIT = 12e3;
-/**
-* 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_MARKDOWN_BLOCK_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;
-const MAX_LABEL = 100;
-const MAX_STATUS = 50;
-const MAX_REASONING = 2800;
-function clampTo(s, max) {
-	const t = s.trim();
-	return t.length > max ? `${t.slice(0, max - 1)}…` : t;
-}
-function clampLabel(s) {
-	return clampTo(s, MAX_LABEL);
-}
-/** Wrap tool activity (a command line, tool title, or tool output) in a CommonMark code
-*  span so it renders monospace and verbatim — Slack posts these as `markdown` blocks, so
-*  unwrapped text with `*` / `_` / `#` would otherwise be interpreted as emphasis. A
-*  single-line value uses an inline span, multi-line (or `block`-forced) a fenced block;
-*  the delimiter is grown past the longest internal backtick run so values containing
-*  backticks stay intact (CommonMark's variable-length fence rule). */
-function codeSpan(s, block = false) {
-	const text = s.trim();
-	if (!text) return "";
-	const longestRun = Math.max(0, ...[...text.matchAll(/`+/g)].map((m) => m[0].length));
-	if (block || text.includes("\n")) {
-		const fence = "`".repeat(Math.max(3, longestRun + 1));
-		return `${fence}\n${text}\n${fence}`;
-	}
-	const ticks = "`".repeat(longestRun + 1);
-	const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
-	return `${ticks}${pad}${text}${pad}${ticks}`;
-}
-const MAX_TOOL_OUTPUT = 2800;
-function capOutput(s) {
-	const t = s.trim();
-	return t.length > MAX_TOOL_OUTPUT ? `${t.slice(0, MAX_TOOL_OUTPUT - 1)}…` : t;
-}
-/** 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. */
-function extractToolOutput(update) {
-	const content = update.content;
-	if (Array.isArray(content)) {
-		const parts = [];
-		for (const item of content) {
-			if (!item || typeof item !== "object") continue;
-			if (item.type !== "content") continue;
-			const block = item.content;
-			if (block?.type === "text" && block.text) parts.push(block.text);
-		}
-		if (parts.length) return parts.join("\n").trim();
-	}
-	return typeof update.rawOutput === "string" ? update.rawOutput.trim() : "";
-}
-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.
-*  Posted as a `markdown` block, so emphasis is CommonMark (`**bold**`), not mrkdwn. */
-function renderPlan(entries) {
-	return [":clipboard: **Plan**", ...entries.map((e) => `${planIcon(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
-}
-/** Render the accumulated reasoning trace (high mode) as one in-place message. Posted as
-*  a `markdown` block (verbatim CommonMark, so `**bold**`), tail-clamped to a compact cap
-*  — the newest thinking is the most relevant, so keep the end and mark truncation with a
-*  leading ellipsis. */
-function renderReasoning(buf) {
-	const trimmed = buf.trim();
-	return `:thought_balloon: **Thinking**\n${trimmed.length > MAX_REASONING ? `…${trimmed.slice(-2800)}` : trimmed}`;
-}
-var OutputConverger = class {
-	mode;
-	buf = "";
-	reasoningBuf = "";
-	reasoningDirty = false;
-	activity = [];
-	toolTitles = /* @__PURE__ */ new Map();
-	toolOutputs = /* @__PURE__ */ new Map();
-	emittedOutput = /* @__PURE__ */ new Set();
-	constructor(mode) {
-		this.mode = mode;
-	}
-	/** True while body text OR reasoning is pending — 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 and streamed thinking updates its in-place block at most once per window. */
-	hasBuffered() {
-		return this.buf.trim().length > 0 || this.reasoningDirty;
-	}
-	/** Flush pending output for the idle timer: in high mode one in-place `reasoning` update
-	*  carrying the reasoning accumulated since the last flush, THEN the buffered body
-	*  (verbatim markdown split into ≤block-limit `post` sections — each a Block Kit
-	*  `markdown` block, no mrkdwn conversion). Reasoning is emitted first so its in-place
-	*  block is first-posted ABOVE the reply: thinking precedes the answer (§9.1), so the
-	*  Thinking block must sit above it, not below. */
-	flushBuffered() {
-		return [...this.drainReasoning(), ...this.flush()];
-	}
-	/** Drain reasoning buffered since the last flush into a 0-or-1-length action list (only
-	*  high mode ever sets `reasoningDirty`). Callers place it before the body flush so the
-	*  Thinking block posts above the reply. */
-	drainReasoning() {
-		if (!this.reasoningDirty) return [];
-		this.reasoningDirty = false;
-		return [{
-			kind: "reasoning",
-			text: renderReasoning(this.reasoningBuf)
-		}];
-	}
-	flush() {
-		const text = this.buf;
-		this.buf = "";
-		if (!text.trim()) return [];
-		return splitIntoSections(text).map((t) => ({
-			kind: "post",
-			text: t
-		}));
-	}
-	/**
-	* Record an activity label and build the loading-status action carrying the rolling
-	* window as `loading_messages`. Consecutive repeats collapse to nothing (returns []),
-	* which throttles streamed thought chunks down to one status update per thinking run.
-	*/
-	pushActivity(raw) {
-		const label = clampTo(raw, MAX_STATUS);
-		if (this.activity[this.activity.length - 1] === label) return [];
-		this.activity.push(label);
-		if (this.activity.length > MAX_ACTIVITY) this.activity.shift();
-		return [{
-			kind: "set-status",
-			text: label,
-			loadingMessages: [...this.activity]
-		}];
-	}
-	/** Resolve a tool call's display label, reusing a known title when an update omits it. */
-	toolLabel(update) {
-		const id = update.toolCallId;
-		if (update.title) {
-			if (id) this.toolTitles.set(id, update.title);
-			return update.title;
-		}
-		return (id && this.toolTitles.get(id)) ?? id ?? "tool";
-	}
-	/** high mode: surface a finished tool's output as a code-block `tool-output` action.
-	*  Tracks the latest output across streamed updates and emits it exactly once, when the
-	*  call reaches a terminal status (completed/failed) — so partial output isn't posted
-	*  early and the final result isn't re-posted. Returns [] when there's nothing to post. */
-	drainToolOutput(update) {
-		const id = update.toolCallId;
-		if (!id) return [];
-		if (update.content !== void 0 || update.rawOutput !== void 0) {
-			const out = extractToolOutput(update);
-			if (out) this.toolOutputs.set(id, out);
-			else this.toolOutputs.delete(id);
-		}
-		if (!(update.status === "completed" || update.status === "failed") || this.emittedOutput.has(id)) return [];
-		const text = this.toolOutputs.get(id);
-		if (!text) return [];
-		this.emittedOutput.add(id);
-		this.toolOutputs.delete(id);
-		return [{
-			kind: "tool-output",
-			text: `${update.status === "failed" ? ":x:" : ":page_facing_up:"}\n${codeSpan(capOutput(text), true)}`
-		}];
-	}
-	onUpdate(update) {
-		switch (update.sessionUpdate) {
-			case "agent_message_chunk": {
-				const content = update.content;
-				if (content?.type === "text") this.buf += content.text ?? "";
-				return [];
-			}
-			case "agent_thought_chunk":
-				if (this.mode === "high") {
-					const text = update.content?.text ?? "";
-					if (text) {
-						this.reasoningBuf += text;
-						if (this.reasoningBuf.length > MAX_REASONING * 2) this.reasoningBuf = this.reasoningBuf.slice(-2800 * 2);
-						this.reasoningDirty = true;
-					}
-				}
-				return [...this.flush(), ...this.pushActivity(THINKING)];
-			case "tool_call":
-			case "tool_call_update": {
-				const u = update;
-				const label = this.toolLabel(u);
-				const status = this.pushActivity(label);
-				if (this.mode === "low") return [...this.flush(), ...status];
-				const actions = [
-					...this.flush(),
-					...status,
-					{
-						kind: "progress",
-						text: `:hammer_and_wrench: ${codeSpan(label)}`
-					}
-				];
-				if (this.mode === "high") actions.push(...this.drainToolOutput(u));
-				return actions;
-			}
-			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 reasoning = this.drainReasoning();
-		const footer = link ? [{
-			kind: "notice",
-			text: `:white_check_mark: done — [details](${link})`
-		}] : [];
-		return [
-			...reasoning,
-			...this.flush(),
-			clear,
-			...footer
-		];
-	}
-};
-//#endregion
 //#region ../../node_modules/.pnpm/croner@10.0.1/node_modules/croner/dist/croner.js
 function T(s) {
 	return Date.UTC(s.y, s.m - 1, s.d, s.h, s.i, s.s);
@@ -83200,6 +83502,7 @@ var CpClient = class {
 			this.deps.daemonId = ok.daemonId;
 			this.deps.onDaemonId?.(ok.daemonId);
 		}
+		this.deps.onWebAppUrl?.(ok.webAppUrl);
 		this.state = "REGISTERING";
 		const snap = (await this.request("register", {
 			host: this.deps.host,
@@ -83465,6 +83768,12 @@ var CpClient = class {
 			case "webchat/close":
 				this.deps.onWebchatClose?.(frame.payload);
 				return;
+			case "webchat/set-model":
+				this.deps.onWebchatSetModel?.(frame.payload);
+				return;
+			case "webchat/cancel":
+				this.deps.onWebchatCancel?.(frame.payload);
+				return;
 			default:
 				this.deps.log.debug(`cp: ignoring ${frame.type}`);
 				return;
@@ -84386,6 +84695,9 @@ function chunkText(text) {
 	return out;
 }
 const IDLE_FLUSH_MS = 2e3;
+/** Public Web App console origin used for session deep links when neither a local
+*  `webAppUrl` config nor a CP-provided one is set — so "View session" always resolves. */
+const DEFAULT_WEB_APP_URL = "https://app.agentconnect.md";
 /** Build the wire SessionKey (protocol §5) for a pending turn — what `drain/done`
 *  reports as released so the CP may reassign it. Uses the real `thread` (absent for
 *  a channel-root message), NOT `statusThread` (which falls back to msgId): the CP
@@ -84578,6 +84890,8 @@ var Daemon = class Daemon {
 					this.onInbound(msg);
 				},
 				onChannelsChanged: () => void this.refreshChannels(conn),
+				onStatusAction: (a) => this.handleSlackStatusAction(a),
+				onStatusInfo: (key) => this.statusInfoForKey(key),
 				log: this.log,
 				boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
 			});
@@ -84755,6 +85069,8 @@ var Daemon = class Daemon {
 						this.onInbound(msg);
 					},
 					onChannelsChanged: () => void this.refreshChannels(conn),
+					onStatusAction: (a) => this.handleSlackStatusAction(a),
+					onStatusInfo: (key) => this.statusInfoForKey(key),
 					log: this.log,
 					boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
 				});
@@ -84919,6 +85235,55 @@ var Daemon = class Daemon {
 	handleWebchatClose(m) {
 		this.log.debug(`webchat: conversation ${m.conversationId} closed by client`);
 	}
+	/** The local session key a webchat conversation maps to — mirrors `handleWebchatMessage`
+	*  (channel = conversationId, statusThread = the stable `webchat:<id>` msgId, no thread). */
+	webchatSessionKey(conversationId, agentId) {
+		return sessionKey("webchat", conversationId, `webchat:${conversationId}`, agentId);
+	}
+	/** Switch a session's model by its local key — the core shared by the webchat
+	*  `set-model` frame and the Slack status-bar select. Records the sticky per-session
+	*  override (re-applied on every turn by dispatch) and, if the ACP session is warm,
+	*  applies it live now and re-pushes the status bar. Never changes the agent default. */
+	setModelByKey(key, model) {
+		const rec = this.store.getSession(key);
+		if (!rec) return;
+		this.store.setModelOverride(key, model);
+		this.log.info(`session ${key} model override → "${model}"`);
+		const acpSessionId = rec.acpSessionId;
+		const host = this.hosts.get(rec.agentId);
+		if (!acpSessionId || !host?.hasSession(acpSessionId)) return;
+		host.setSessionModel(acpSessionId, model).then((applied) => {
+			const p = this.pending.get(acpSessionId);
+			if (applied && p) this.emitStatusBar(p);
+		}).catch((err) => this.log.warn(`set-model failed: ${err.message}`));
+	}
+	/** Cancel the in-flight turn for a local session key — the `!cancel` core (interrupt,
+	*  NO mute) shared by the Slack status-bar Cancel button. No-op if nothing is running. */
+	cancelSessionByKey(key) {
+		const rec = this.store.getSession(key);
+		if (!rec?.acpSessionId || !this.pending.has(rec.acpSessionId)) return;
+		this.interruptTurn(rec.agentId, rec.acpSessionId, key, "cancel");
+	}
+	/** Handle a webchat in-session model switch (C→D `webchat/set-model`). */
+	handleWebchatSetModel(m) {
+		this.setModelByKey(this.webchatSessionKey(m.conversationId, m.agentId), m.model);
+	}
+	/** Handle a webchat cancel (C→D `webchat/cancel`) — the status-bar "Cancel". Interrupts
+	*  the conversation's in-flight turn like `!cancel` (no mute; follow-ups still dispatch).
+	*  Resolved by conversationId (the frame carries no agentId). No-op when idle. */
+	handleWebchatCancel(m) {
+		for (const [acpSessionId, p] of this.pending) if (p.webchat?.conversationId === m.conversationId) {
+			this.interruptTurn(p.agentId, acpSessionId, p.sessionKey, "cancel");
+			return;
+		}
+		this.log.debug(`webchat cancel: no in-flight turn for conversation ${m.conversationId}`);
+	}
+	/** Route a Slack status-bar Block Kit interaction (model select / Cancel button) to the
+	*  shared key-based cores. `sessionKey` rides the block; no-op on an unknown key. */
+	handleSlackStatusAction(a) {
+		if (a.kind === "cancel") this.cancelSessionByKey(a.sessionKey);
+		else if (a.model) this.setModelByKey(a.sessionKey, a.model);
+	}
 	/** 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() {
@@ -84996,14 +85361,19 @@ var Daemon = class Daemon {
 				conn?.postMessage(msg.channel, rec ? `🔇 Nothing is running. ${muteNote}` : "Nothing is running to stop.", thread);
 				return;
 			}
-			this.queued.delete(acpSessionId);
-			this.log.info(`command: stop → agent "${target.agentId}" session ${acpSessionId}`);
-			this.store.setSessionState(key, "cancelling", this.clock.now());
-			this.hosts.get(target.agentId)?.cancel(acpSessionId).catch((err) => this.log.error(`command stop: cancel failed: ${err.message}`));
-			this.armCancelBackstop(target.agentId, acpSessionId, key);
+			this.interruptTurn(target.agentId, acpSessionId, key, "stop");
 			conn?.postMessage(msg.channel, `🛑 Stopped. ${muteNote}`, thread);
 			return;
 		}
+		if (command.kind === "cancel") {
+			if (!inflight) {
+				conn?.postMessage(msg.channel, "Nothing is running to cancel.", thread);
+				return;
+			}
+			this.interruptTurn(target.agentId, acpSessionId, key, "cancel");
+			conn?.postMessage(msg.channel, "🛑 Cancelled.", thread);
+			return;
+		}
 		if (!command.text) {
 			conn?.postMessage(msg.channel, "Usage: `!queue <message>` — runs when the current turn finishes.", thread);
 			return;
@@ -85117,6 +85487,7 @@ var Daemon = class Daemon {
 			agentId,
 			platform: msg.platform,
 			sessionKey: key,
+			acpSessionId: sessionId,
 			channel: msg.channel,
 			thread: msg.thread,
 			statusThread,
@@ -85133,7 +85504,10 @@ var Daemon = class Daemon {
 		this.pending.set(sessionId, p);
 		try {
 			const host = await this.ensureHostAsync(agentId);
+			const override = this.store.getModelOverride(key);
+			if (override) await host.setSessionModel(sessionId, override).catch((err) => this.log.debug(`model override "${override}" not applied: ${err.message}`));
 			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
+			this.emitStatusBar(p);
 			const { stopReason, usage } = await host.prompt(sessionId, blocks);
 			if (usage) this.store.setTokenUsage(key, {
 				totalTokens: usage.totalTokens,
@@ -85143,6 +85517,7 @@ var Daemon = class Daemon {
 				cachedReadTokens: usage.cachedReadTokens ?? void 0,
 				cachedWriteTokens: usage.cachedWriteTokens ?? void 0
 			});
+			this.emitStatusBar(p);
 			const mergedUsage = this.store.getUsage(key);
 			if (Object.keys(mergedUsage).length > 0) try {
 				this.cpClient?.emitUsageReport({
@@ -85173,7 +85548,7 @@ var Daemon = class Daemon {
 					...usage?.totalTokens !== void 0 ? { usage: { used: usage.totalTokens } } : {}
 				});
 			} else {
-				const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
+				const link = this.sessionLink(sessionId);
 				for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
 			}
 			for (const ev of rec.onFinal()) this.recordEvent(agentId, msg.channel, statusThread, ev);
@@ -85198,6 +85573,17 @@ var Daemon = class Daemon {
 		this.flushQueued(agentId, sessionId, integrationId);
 		return sessionId;
 	}
+	/** Interrupt an in-flight turn (shared by `!stop`, `!cancel`, and webchat cancel):
+	*  drop anything queued behind it, mark the session `cancelling`, send ACP
+	*  `session/cancel`, and arm the force backstop. Muting is the CALLER's concern —
+	*  `!stop` mutes, `!cancel`/webchat-cancel do not. `reason` is just for the log line. */
+	interruptTurn(agentId, acpSessionId, key, reason) {
+		this.queued.delete(acpSessionId);
+		this.log.info(`command: ${reason} → agent "${agentId}" session ${acpSessionId}`);
+		this.store.setSessionState(key, "cancelling", this.clock.now());
+		this.hosts.get(agentId)?.cancel(acpSessionId).catch((err) => this.log.error(`command ${reason}: cancel failed: ${err.message}`));
+		this.armCancelBackstop(agentId, acpSessionId, key);
+	}
 	/** After `!stop` sends session/cancel, give the agent `cancelBackstopMs` to yield.
 	*  If the turn is still in flight when the timer fires, the agent ignored the
 	*  cancel — force-stop its host (the only hard kill available) so the session
@@ -85275,6 +85661,95 @@ var Daemon = class Daemon {
 					p.reasoningTs = await conn.postMessage(p.channel, action.text, p.thread);
 				}
 				return;
+			case "status-bar":
+				if (p.statusBarTs) await conn.updateBlocks(p.channel, p.statusBarTs, action.blocks, action.text);
+				else if (!p.statusBarAttempted) {
+					p.statusBarAttempted = true;
+					p.statusBarTs = await conn.postBlocks(p.channel, action.blocks, action.text, p.thread);
+				}
+				return;
+		}
+	}
+	/** Web App console base URL the CP sent on `auth/ok` (its own console origin). A local
+	*  `webAppUrl` config overrides it; undefined until auth completes / if neither is set. */
+	cpWebAppUrl;
+	/** The Web App console base for session deep links: explicit local `webAppUrl`, else the
+	*  CP-provided one, else the public default (`DEFAULT_WEB_APP_URL`). `<base>/sessions/<id>`
+	*  — always resolves, so the View-session link is always available. */
+	sessionLink(acpSessionId) {
+		return `${(this.cfg.webAppUrl ?? this.cpWebAppUrl ?? DEFAULT_WEB_APP_URL).replace(/\/$/, "")}/sessions/${acpSessionId}`;
+	}
+	/** Assemble a status snapshot from the parts (agent config + host model selector +
+	*  folded ACP usage). Shared by `buildStatusInfo` (per-turn Pending) and
+	*  `statusInfoForKey` (the ⚙-modal, keyed by session). */
+	statusInfoFrom(agentId, sessionKey, acpSessionId, opts = {}) {
+		const agent = this.agents.get(agentId);
+		const usage = this.store.getUsage(sessionKey);
+		const model = this.hosts.get(agentId)?.modelOptions?.();
+		return {
+			model: model?.current ?? agent?.runtimeOverrides?.model,
+			effort: agent?.reasoningEffort,
+			fastMode: agent?.fastMode,
+			contextUsed: usage.contextUsed,
+			contextSize: usage.contextSize,
+			totalTokens: usage.totalTokens,
+			costAmount: usage.costAmount,
+			costCurrency: usage.costCurrency,
+			...opts.breakdown ? {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				thoughtTokens: usage.thoughtTokens,
+				cachedReadTokens: usage.cachedReadTokens,
+				cachedWriteTokens: usage.cachedWriteTokens
+			} : {},
+			...model?.models?.length ? { models: model.models } : {},
+			...acpSessionId ? { sessionId: acpSessionId } : {}
+		};
+	}
+	/** Per-turn status snapshot for the live in-thread line + webchat frame (no breakdown). */
+	buildStatusInfo(p) {
+		return this.statusInfoFrom(p.agentId, p.sessionKey, p.acpSessionId);
+	}
+	/** Status snapshot (WITH the full token breakdown) + deep link for a session by KEY — the
+	*  source of truth the Slack connection queries to build the ⚙ controls modal on click.
+	*  Undefined on unknown key. */
+	statusInfoForKey(sessionKey) {
+		const rec = this.store.getSession(sessionKey);
+		if (!rec) return void 0;
+		const info = this.statusInfoFrom(rec.agentId, sessionKey, rec.acpSessionId ?? void 0, { breakdown: true });
+		const link = rec.acpSessionId ? this.sessionLink(rec.acpSessionId) : void 0;
+		return {
+			info,
+			...link ? { link } : {}
+		};
+	}
+	/** Emit/refresh the session's status bar (model / context / tokens / cost). Called at
+	*  turn start (model + carried-over usage), on each `usage_update` (live context/cost),
+	*  and at turn end (token totals). Deduped against the last snapshot so an unchanged
+	*  update is a no-op. Webchat rides a status-only `webchat/output` frame; every other
+	*  (Slack / headless) target gets the in-place `status-bar` action — headless no-ops in
+	*  applyAction (no connection), which is fine. */
+	emitStatusBar(p) {
+		const info = this.buildStatusInfo(p);
+		const key = JSON.stringify(info);
+		if (key === p.lastStatusBar) return;
+		if (p.webchat) {
+			if (!Object.entries(info).some(([k, v]) => k !== "sessionId" && v !== void 0)) return;
+			p.lastStatusBar = key;
+			const wc = p.webchat;
+			this.cpClient?.emitWebchatOutput({
+				conversationId: wc.conversationId,
+				turnId: wc.turnId,
+				index: wc.index++,
+				status: info
+			});
+		} else {
+			p.lastStatusBar = key;
+			this.enqueueApply(p, {
+				kind: "status-bar",
+				text: renderStatusBar(info),
+				blocks: buildStatusBlocks(info, p.sessionKey, this.sessionLink(p.acpSessionId))
+			});
 		}
 	}
 	/** Serialize action application per session so in-place edits never race on the
@@ -85300,12 +85775,15 @@ var Daemon = class Daemon {
 	onAcpUpdate(_agentId, sessionId, update) {
 		const p = this.pending.get(sessionId);
 		if (!p) return;
-		if (update?.sessionUpdate === "usage_update") this.store.setUsageSnapshot(p.sessionKey, {
-			contextUsed: update.used,
-			contextSize: update.size,
-			costAmount: update.cost?.amount ?? void 0,
-			costCurrency: update.cost?.currency ?? void 0
-		});
+		if (update?.sessionUpdate === "usage_update") {
+			this.store.setUsageSnapshot(p.sessionKey, {
+				contextUsed: update.used,
+				contextSize: update.size,
+				costAmount: update.cost?.amount ?? void 0,
+				costCurrency: update.cost?.currency ?? void 0
+			});
+			this.emitStatusBar(p);
+		}
 		if (update?.sessionUpdate === "session_info_update" && update.title !== void 0) this.store.setSessionTitle(p.sessionKey, update.title);
 		if (p.webchat) this.emitWebchatUpdate(p, update);
 		else {
@@ -85776,6 +86254,10 @@ var Daemon = class Daemon {
 				persistDaemonId(root, id);
 				this.log.info(`cp: adopted daemonId ${id} from auth/ok`);
 			},
+			onWebAppUrl: (url) => {
+				this.cpWebAppUrl = url;
+				if (url) this.log.debug(`cp: web app url ${url} (session deep links)`);
+			},
 			agentVersion: DAEMON_VERSION,
 			host: hostname(),
 			heartbeatDefaultMs: cp.heartbeatMs,
@@ -85821,6 +86303,8 @@ var Daemon = class Daemon {
 			workspaceGit: createWorkspaceGit((id) => this.agents.get(id)?.workspace.path),
 			onWebchatMessage: (m) => this.handleWebchatMessage(m),
 			onWebchatClose: (m) => this.handleWebchatClose(m),
+			onWebchatSetModel: (m) => this.handleWebchatSetModel(m),
+			onWebchatCancel: (m) => this.handleWebchatCancel(m),
 			clock: systemClock,
 			connect: () => ClientTransport.dial(url),
 			log: this.log