@agentconnect.md/daemon 1.0.0-rc.159 → 1.0.0-rc.160

package/dist/index.js

@@ -13629,6 +13629,8 @@ const WebchatStatus = object({
 	costAmount: number().optional(),
 	costCurrency: string().optional(),
 	models: array(string()).optional(),
+	efforts: array(string()).optional(),
+	fastModeAvailable: boolean().optional(),
 	sessionId: string().optional()
 });
 //#endregion
@@ -13682,6 +13684,16 @@ const FRAME_SCHEMAS = {
 		agentId: string().uuid(),
 		model: string()
 	}),
+	"webchat/set-effort": object({
+		conversationId: string().uuid(),
+		agentId: string().uuid(),
+		effort: string()
+	}),
+	"webchat/set-fast": object({
+		conversationId: string().uuid(),
+		agentId: string().uuid(),
+		fastMode: boolean()
+	}),
 	"webchat/cancel": object({ conversationId: string().uuid() }),
 	"route/assign": RouteAssign,
 	"route/assign/ack": RouteAssignAck,
@@ -13760,6 +13772,8 @@ discriminatedUnion("type", [
 	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/set-effort", FRAME_SCHEMAS["webchat/set-effort"]),
+	frame("webchat/set-fast", FRAME_SCHEMAS["webchat/set-fast"]),
 	frame("webchat/cancel", FRAME_SCHEMAS["webchat/cancel"]),
 	frame("route/assign", FRAME_SCHEMAS["route/assign"]),
 	frame("route/assign/ack", FRAME_SCHEMAS["route/assign/ack"]),
@@ -18183,6 +18197,11 @@ function planConfigSelection(configOptions, category, desired) {
 		value: desired
 	};
 }
+/** Effort sentinel `'ultracode'` (matching Claude Code's own `ultracode` settings
+*  key) meaning xhigh reasoning PLUS standing dynamic-workflow orchestration. It is
+*  deliberately NOT a `thought_level` select value: the claude-acp runtime rejects
+*  effort="ultracode" ("Invalid value"). See {@link claudeSessionMeta}. */
+const ULTRACODE_EFFORT = "ultracode";
 /** The session `_meta` sent to a Claude runtime on session/new and session/load
 *  (`_meta.claudeCode.options` is spread into the SDK `query()` options layer), or
 *  undefined off Claude runtimes. Two things ride on it:
@@ -18225,6 +18244,39 @@ function modelOptionsFrom(configOptions) {
 		models
 	};
 }
+/**
+* Extract the reasoning-effort selector from a session's `configOptions` (ACP
+* `category: "thought_level"`, `type: "select"`). Effort support is per-model: a runtime
+* only advertises this select for models that support effort (e.g. Opus/Sonnet, not
+* Haiku), so a missing/empty selector means the CURRENT model has no effort → returns
+* null and the picker is hidden. When the model DOES support effort, Claude runtimes get
+* the synthetic `max`/`ultracode` entries appended if not already offered (see
+* {@link ULTRACODE_EFFORT}) — never fabricated for a model that lacks effort entirely.
+*/
+function effortOptionsFrom(configOptions, isClaudeRuntime) {
+	const opt = configOptions?.find((o) => o.category === "thought_level" && o.type === "select");
+	if (!opt || opt.type !== "select") return null;
+	const advertised = opt.options.flatMap((o) => "group" in o ? o.options : [o]).map((o) => o.value);
+	if (advertised.length === 0) return null;
+	const efforts = [...advertised];
+	if (isClaudeRuntime) {
+		for (const extra of ["max", ULTRACODE_EFFORT]) if (!efforts.includes(extra)) efforts.push(extra);
+	}
+	return {
+		current: opt.currentValue,
+		efforts
+	};
+}
+/**
+* Extract the fast-mode toggle from a session's `configOptions` (ACP `category:
+* "model_config"`, `type: "select"` with on/off values). Returns null when the current
+* model advertises no fast toggle.
+*/
+function fastOptionFrom(configOptions) {
+	const opt = configOptions?.find((o) => o.category === "model_config" && o.type === "select");
+	if (!opt || opt.type !== "select") return null;
+	return { current: opt.currentValue === "on" };
+}
 var AcpHost = class {
 	runtime;
 	opts;
@@ -18235,6 +18287,8 @@ var AcpHost = class {
 	canLoad = false;
 	promptCaps = {};
 	lastModelOptions = null;
+	lastEffortOptions = null;
+	lastFastOption = null;
 	sessionConfigs = /* @__PURE__ */ new Map();
 	negotiatedProtocolVersion;
 	constructor(runtime, opts) {
@@ -18299,8 +18353,12 @@ var AcpHost = class {
 	promptSupports(kind) {
 		return Boolean(this.promptCaps[kind]);
 	}
-	async newSession(cwd, mcpServers = []) {
-		const _meta = claudeSessionMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
+	/** Create a fresh ACP session. `effortOverride` (the sticky per-session effort choice,
+	*  when set) takes the place of the agent default in the Claude `_meta` — the only
+	*  channel `ultracode` can ride (the `thought_level` select rejects it); select-based
+	*  effort/model/fast overrides are layered on afterward by the daemon at turn start. */
+	async newSession(cwd, mcpServers = [], effortOverride) {
+		const _meta = claudeSessionMeta(effortOverride ?? this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
 		const res = await this.conn.agent.request(methods.agent.session.new, {
 			cwd,
 			mcpServers,
@@ -18308,7 +18366,7 @@ var AcpHost = class {
 		});
 		this.live.add(res.sessionId);
 		const configOptions = await this.applySessionConfig(res.sessionId, res.configOptions);
-		this.lastModelOptions = modelOptionsFrom(configOptions);
+		this.refreshOptionCaches(configOptions);
 		this.sessionConfigs.set(res.sessionId, configOptions);
 		return res.sessionId;
 	}
@@ -18350,23 +18408,38 @@ var AcpHost = class {
 		}
 		return options;
 	}
-	/** The model selector advertised by the most recent session/new, or null if the
-	*  agent exposed none. Used by the runtime probe to report available models. */
+	/** Re-derive the model / effort / fast selector caches from a reconciled option set. */
+	refreshOptionCaches(configOptions) {
+		this.lastModelOptions = modelOptionsFrom(configOptions);
+		this.lastEffortOptions = effortOptionsFrom(configOptions, this.isClaudeRuntime());
+		this.lastFastOption = fastOptionFrom(configOptions);
+	}
+	/** The model selector advertised by the most recent session/new|load, or null if the
+	*  agent exposed none. Used by the runtime probe + status bar to report models. */
 	modelOptions() {
 		return this.lastModelOptions;
 	}
+	/** The reasoning-effort selector (incl. synthetic ultracode/max on Claude runtimes)
+	*  from the most recent session/new|load, or null if none is offered. */
+	effortOptions() {
+		return this.lastEffortOptions;
+	}
+	/** The fast-mode toggle from the most recent session/new|load, or null if the current
+	*  model offers no fast mode. */
+	fastModeOption() {
+		return this.lastFastOption;
+	}
 	/**
-	* 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.
+	* Apply one select config option to an ALREADY-RUNNING session via ACP
+	* `session/set_config_option`, refreshing the cached option set + selector caches on
+	* success. Returns true iff applied: false when the session isn't live here, the
+	* runtime advertises no such selector, the value isn't offered, or it's already set.
 	*/
-	async setSessionModel(sessionId, model) {
+	async setSessionConfig(sessionId, category, value) {
 		if (!this.live.has(sessionId)) return false;
-		const plan = planConfigSelection(this.sessionConfigs.get(sessionId), "model", model);
+		const plan = planConfigSelection(this.sessionConfigs.get(sessionId), category, value);
 		if ("skip" in plan) {
-			this.opts.log?.debug(`acp: setSessionModel "${model}" on ${sessionId} not applied — ${plan.skip}`);
+			this.opts.log?.debug(`acp: set ${category}="${value}" on ${sessionId} not applied — ${plan.skip}`);
 			return false;
 		}
 		const res = await this.conn.agent.request(methods.agent.session.setConfigOption, {
@@ -18375,10 +18448,28 @@ var AcpHost = class {
 			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}"`);
+		this.refreshOptionCaches(res.configOptions);
+		this.opts.log?.info(`acp: session ${sessionId} ${category} set to "${value}"`);
 		return true;
 	}
+	/** Switch the model of an already-running session (ACP `model` select) — the
+	*  mid-session counterpart of the model applied at new/load. */
+	async setSessionModel(sessionId, model) {
+		return this.setSessionConfig(sessionId, "model", model);
+	}
+	/** Switch the reasoning effort of an already-running session (ACP `thought_level`
+	*  select). Returns false for `ultracode` — it isn't a select value and can only ride
+	*  session `_meta` at new/load, so the caller relies on the override being re-applied
+	*  when the session is next (re)created or resumed. */
+	async setSessionEffort(sessionId, effort) {
+		if (effort === "ultracode") return false;
+		return this.setSessionConfig(sessionId, "thought_level", effort);
+	}
+	/** Toggle fast mode on an already-running session (ACP `model_config` on/off select).
+	*  False when the current model offers no fast toggle. */
+	async setSessionFastMode(sessionId, on) {
+		return this.setSessionConfig(sessionId, "model_config", on ? "on" : "off");
+	}
 	/** The ACP protocol version negotiated at initialize, or undefined before the
 	*  handshake completed. Used by the runtime probe to report ACP coverage. */
 	acpProtocolVersion() {
@@ -18396,10 +18487,10 @@ var AcpHost = class {
 	*  restores its own history server-side; its replayed session/update stream is
 	*  suppressed so it isn't re-posted. Throws if the agent can't load the id
 	*  (caller falls back to newSession). */
-	async loadSession(sessionId, cwd) {
+	async loadSession(sessionId, cwd, effortOverride) {
 		this.loadingSessions.add(sessionId);
 		try {
-			const _meta = claudeSessionMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
+			const _meta = claudeSessionMeta(effortOverride ?? this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
 			const res = await this.conn.agent.request(methods.agent.session.load, {
 				sessionId,
 				cwd,
@@ -18408,7 +18499,7 @@ var AcpHost = class {
 			});
 			this.live.add(sessionId);
 			const configOptions = await this.applySessionConfig(sessionId, res.configOptions);
-			this.lastModelOptions = modelOptionsFrom(configOptions);
+			this.refreshOptionCaches(configOptions);
 			this.sessionConfigs.set(sessionId, configOptions);
 			this.opts.log?.info(`acp: resumed session ${sessionId} via session/load`);
 		} catch (err) {
@@ -24173,7 +24264,8 @@ 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, modelOverride TEXT
+        usage TEXT, muted INTEGER, triggeredBy TEXT, title TEXT, modelOverride TEXT,
+        effortOverride TEXT, fastModeOverride INTEGER, outputModeOverride 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).
@@ -24219,10 +24311,11 @@ 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`, `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. */
+	*  thread mute), `sessions.triggeredBy`, `sessions.title`, `sessions.modelOverride`,
+	*  `sessions.effortOverride` and `sessions.fastModeOverride` (the sticky per-session
+	*  model / reasoning-effort / fast-mode choices) 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");
@@ -24230,6 +24323,9 @@ var LocalStore = class {
 		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");
+		if (!cols.some((c) => c.name === "effortOverride")) this.db.exec("ALTER TABLE sessions ADD COLUMN effortOverride TEXT");
+		if (!cols.some((c) => c.name === "fastModeOverride")) this.db.exec("ALTER TABLE sessions ADD COLUMN fastModeOverride INTEGER");
+		if (!cols.some((c) => c.name === "outputModeOverride")) this.db.exec("ALTER TABLE sessions ADD COLUMN outputModeOverride TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -24327,6 +24423,38 @@ var LocalStore = class {
 	setModelOverride(key, model) {
 		this.db.prepare("UPDATE sessions SET modelOverride = ? WHERE key = ?").run(model, key);
 	}
+	/** The session-scoped reasoning-effort override (set via the status-bar effort picker),
+	*  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. */
+	getEffortOverride(key) {
+		return this.db.prepare("SELECT effortOverride FROM sessions WHERE key = ?").get(key)?.effortOverride ?? void 0;
+	}
+	/** Persist the session-scoped reasoning-effort override. No-op on an unknown key. */
+	setEffortOverride(key, effort) {
+		this.db.prepare("UPDATE sessions SET effortOverride = ? WHERE key = ?").run(effort, key);
+	}
+	/** The session-scoped fast-mode override (set via the status-bar fast toggle), or
+	*  undefined if the session runs on the agent's default. Stored as 0/1; sticky across
+	*  turns and restarts, re-applied to the ACP session on each dispatch. */
+	getFastModeOverride(key) {
+		const row = this.db.prepare("SELECT fastModeOverride FROM sessions WHERE key = ?").get(key);
+		return row?.fastModeOverride === null || row?.fastModeOverride === void 0 ? void 0 : row.fastModeOverride === 1;
+	}
+	/** Persist the session-scoped fast-mode override. No-op on an unknown key. */
+	setFastModeOverride(key, fastMode) {
+		this.db.prepare("UPDATE sessions SET fastModeOverride = ? WHERE key = ?").run(fastMode ? 1 : 0, key);
+	}
+	/** The session-scoped Slack output-mode override (set via the status-bar output picker),
+	*  or undefined if the session uses the agent's default. Daemon-side rendering verbosity
+	*  (low/medium/high) — NOT an ACP setting; picked up by the next turn's OutputConverger. */
+	getOutputModeOverride(key) {
+		const v = this.db.prepare("SELECT outputModeOverride FROM sessions WHERE key = ?").get(key)?.outputModeOverride;
+		return v === "low" || v === "medium" || v === "high" ? v : void 0;
+	}
+	/** Persist the session-scoped Slack output-mode override. No-op on an unknown key. */
+	setOutputModeOverride(key, mode) {
+		this.db.prepare("UPDATE sessions SET outputModeOverride = ? WHERE key = ?").run(mode, 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) {
@@ -24589,6 +24717,7 @@ var SessionManager = class {
 		});
 		let rec = this.deps.store.getSession(key);
 		const host = await this.deps.hostFor(agentId);
+		const effortOverride = this.deps.store.getEffortOverride(key);
 		if (!rec || !rec.acpSessionId) {
 			const cwd = await prepareWorkspace(agent);
 			const mcpServers = this.deps.mcpServersFor?.({
@@ -24596,7 +24725,7 @@ var SessionManager = class {
 				channel: msg.channel,
 				thread
 			}) ?? [];
-			const acpSessionId = await host.newSession(cwd, mcpServers);
+			const acpSessionId = await host.newSession(cwd, mcpServers, effortOverride);
 			rec = {
 				key,
 				agentId,
@@ -24616,7 +24745,7 @@ var SessionManager = class {
 			if (host.loadSupported?.()) {
 				this.deps.store.setSessionState(key, "resuming", Date.now());
 				try {
-					await host.loadSession(rec.acpSessionId, cwd);
+					await host.loadSession(rec.acpSessionId, cwd, effortOverride);
 					resumed = true;
 				} catch {}
 			}
@@ -24626,7 +24755,7 @@ var SessionManager = class {
 					channel: msg.channel,
 					thread
 				}) ?? [];
-				const acpSessionId = await host.newSession(cwd, mcpServers);
+				const acpSessionId = await host.newSession(cwd, mcpServers, effortOverride);
 				rec = {
 					...rec,
 					acpSessionId,
@@ -81400,25 +81529,20 @@ function compactCount(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. */
+/** Render the compact in-thread status line as one `markdown` block — e.g.
+*  `:bar_chart: *opus-4.8* · fast · ctx 120k/200k (60%) · 45.2k tok`. Deliberately narrow:
+*  effort and cost are omitted here (they live in the ⚙ modal) to keep the line short in a
+*  Slack thread. 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
@@ -81426,6 +81550,9 @@ function renderStatusBar(info) {
 const STATUS_ACTION = {
 	manage: "ac_manage",
 	setModel: "ac_set_model",
+	setEffort: "ac_set_effort",
+	setFast: "ac_set_fast",
+	setOutput: "ac_set_output",
 	cancel: "ac_cancel",
 	view: "ac_view"
 };
@@ -81452,23 +81579,24 @@ function buildStatusBlocks(info, sessionKey, link) {
 			action_id: STATUS_ACTION.manage,
 			text: {
 				type: "plain_text",
-				text: ":gear: Manage",
+				text: ":gear:",
 				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")}`;
+/** Format a token count with thousands separators for the modal's usage grid. */
+function fmtCount(n) {
+	return n === void 0 ? void 0 : 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.
+* (model/effort/fast/output selects, Cancel) 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) {
 	const blocks = [];
@@ -81506,23 +81634,115 @@ function buildStatusModal(info, sessionKey, link) {
 			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)
+	const efforts = info.efforts ?? [];
+	if (efforts.length > 0) {
+		const opts = info.effort && !efforts.includes(info.effort) ? [info.effort, ...efforts] : efforts;
+		const option = (e) => ({
+			text: {
+				type: "plain_text",
+				text: clampTo(e, 75)
+			},
+			value: e
+		});
+		blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Effort*"
+			},
+			accessory: {
+				type: "static_select",
+				action_id: STATUS_ACTION.setEffort,
+				placeholder: {
+					type: "plain_text",
+					text: "Effort"
+				},
+				...info.effort ? { initial_option: option(info.effort) } : {},
+				options: opts.map(option)
+			}
+		});
+	}
+	if (info.fastModeAvailable) {
+		const fastOpt = (v) => ({
+			text: {
+				type: "plain_text",
+				text: v === "on" ? "On" : "Off"
+			},
+			value: v
+		});
+		const current = info.fastMode ? "on" : "off";
+		blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Fast mode*"
+			},
+			accessory: {
+				type: "static_select",
+				action_id: STATUS_ACTION.setFast,
+				placeholder: {
+					type: "plain_text",
+					text: "Fast mode"
+				},
+				initial_option: fastOpt(current),
+				options: [fastOpt("on"), fastOpt("off")]
+			}
+		});
+	}
+	if (info.outputMode) {
+		const modeOpt = (v) => ({
+			text: {
+				type: "plain_text",
+				text: v
+			},
+			value: v
+		});
+		blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Output*"
+			},
+			accessory: {
+				type: "static_select",
+				action_id: STATUS_ACTION.setOutput,
+				placeholder: {
+					type: "plain_text",
+					text: "Output"
+				},
+				initial_option: modeOpt(info.outputMode),
+				options: [
+					modeOpt("low"),
+					modeOpt("medium"),
+					modeOpt("high")
+				]
+			}
+		});
+	}
+	const field = (label, value) => value === void 0 ? void 0 : {
+		type: "mrkdwn",
+		text: `*${label}*\n${value}`
+	};
+	let contextValue;
+	if (info.contextUsed !== void 0) contextValue = info.contextSize && info.contextSize > 0 ? `${fmtCount(info.contextUsed)} / ${fmtCount(info.contextSize)} (${Math.round(info.contextUsed / info.contextSize * 100)}%)` : fmtCount(info.contextUsed);
+	let costValue;
+	if (info.costAmount !== void 0) {
+		const cur = info.costCurrency && info.costCurrency !== "USD" ? ` ${info.costCurrency}` : "";
+		costValue = `${!info.costCurrency || info.costCurrency === "USD" ? "$" : ""}${info.costAmount.toFixed(info.costAmount < 1 ? 3 : 2)}${cur}`;
+	}
+	const fields = [
+		field("Context", contextValue),
+		field("Total tokens", fmtCount(info.totalTokens)),
+		field("Cost", costValue),
+		field("Input", fmtCount(info.inputTokens)),
+		field("Output", fmtCount(info.outputTokens)),
+		field("Thought", fmtCount(info.thoughtTokens)),
+		field("Cache read", fmtCount(info.cachedReadTokens)),
+		field("Cache write", fmtCount(info.cachedWriteTokens))
 	].filter(Boolean);
-	blocks.push({
-		type: "context",
-		elements: [{
-			type: "mrkdwn",
-			text: detail.join("  ·  ")
-		}]
+	if (fields.length) blocks.push({
+		type: "section",
+		fields
 	});
 	const actions = [{
 		type: "button",
@@ -81857,6 +82077,36 @@ var SlackConnection = class {
 				model
 			});
 		});
+		this.app.action(STATUS_ACTION.setEffort, async ({ ack, action, body }) => {
+			await ack();
+			const sessionKey = body?.view?.private_metadata ?? action.block_id;
+			const effort = action.selected_option?.value;
+			if (sessionKey && effort) this.deps.onStatusAction?.({
+				kind: "set-effort",
+				sessionKey,
+				effort
+			});
+		});
+		this.app.action(STATUS_ACTION.setFast, async ({ ack, action, body }) => {
+			await ack();
+			const sessionKey = body?.view?.private_metadata ?? action.block_id;
+			const value = action.selected_option?.value;
+			if (sessionKey && value) this.deps.onStatusAction?.({
+				kind: "set-fast",
+				sessionKey,
+				fastMode: value === "on"
+			});
+		});
+		this.app.action(STATUS_ACTION.setOutput, async ({ ack, action, body }) => {
+			await ack();
+			const sessionKey = body?.view?.private_metadata ?? action.block_id;
+			const mode = action.selected_option?.value;
+			if (sessionKey && (mode === "low" || mode === "medium" || mode === "high")) this.deps.onStatusAction?.({
+				kind: "set-output",
+				sessionKey,
+				outputMode: mode
+			});
+		});
 		this.app.action(STATUS_ACTION.cancel, async ({ ack, action, body }) => {
 			await ack();
 			const sessionKey = body?.view?.private_metadata ?? action.value;
@@ -83771,6 +84021,12 @@ var CpClient = class {
 			case "webchat/set-model":
 				this.deps.onWebchatSetModel?.(frame.payload);
 				return;
+			case "webchat/set-effort":
+				this.deps.onWebchatSetEffort?.(frame.payload);
+				return;
+			case "webchat/set-fast":
+				this.deps.onWebchatSetFast?.(frame.payload);
+				return;
 			case "webchat/cancel":
 				this.deps.onWebchatCancel?.(frame.payload);
 				return;
@@ -85264,10 +85520,68 @@ var Daemon = class Daemon {
 		if (!rec?.acpSessionId || !this.pending.has(rec.acpSessionId)) return;
 		this.interruptTurn(rec.agentId, rec.acpSessionId, key, "cancel");
 	}
+	/** Switch a session's reasoning effort by its local key — the effort counterpart of
+	*  {@link setModelByKey}. Records the sticky override and, if the ACP session is warm,
+	*  applies it live via the `thought_level` select. `ultracode` can't ride the select
+	*  (setSessionEffort returns false); it's honored via session `_meta` when the session
+	*  is next (re)created or resumed, and the override still shows on the bar meanwhile. */
+	setEffortByKey(key, effort) {
+		const rec = this.store.getSession(key);
+		if (!rec) return;
+		this.store.setEffortOverride(key, effort);
+		this.log.info(`session ${key} effort override → "${effort}"`);
+		const acpSessionId = rec.acpSessionId;
+		const host = this.hosts.get(rec.agentId);
+		if (!acpSessionId || !host?.hasSession(acpSessionId)) {
+			this.refreshStatusBarForKey(key);
+			return;
+		}
+		host.setSessionEffort(acpSessionId, effort).then(() => this.refreshStatusBarForKey(key)).catch((err) => this.log.warn(`set-effort failed: ${err.message}`));
+	}
+	/** Toggle a session's fast mode by its local key — the fast-mode counterpart of
+	*  {@link setModelByKey}. Records the sticky override and applies it live when the
+	*  current model offers a fast toggle. */
+	setFastByKey(key, fastMode) {
+		const rec = this.store.getSession(key);
+		if (!rec) return;
+		this.store.setFastModeOverride(key, fastMode);
+		this.log.info(`session ${key} fast-mode override → ${fastMode}`);
+		const acpSessionId = rec.acpSessionId;
+		const host = this.hosts.get(rec.agentId);
+		if (!acpSessionId || !host?.hasSession(acpSessionId)) {
+			this.refreshStatusBarForKey(key);
+			return;
+		}
+		host.setSessionFastMode(acpSessionId, fastMode).then(() => this.refreshStatusBarForKey(key)).catch((err) => this.log.warn(`set-fast failed: ${err.message}`));
+	}
+	/** Re-emit the status bar for a session's in-flight turn (if any) so a config change
+	*  (model / effort / fast) is reflected. No-op when the session is idle. */
+	refreshStatusBarForKey(key) {
+		const rec = this.store.getSession(key);
+		const p = rec?.acpSessionId ? this.pending.get(rec.acpSessionId) : void 0;
+		if (p) this.emitStatusBar(p);
+	}
+	/** Set a session's Slack output verbosity by its local key. Purely daemon-side (no ACP):
+	*  the next turn's OutputConverger reads this override, so an in-flight turn keeps its
+	*  current verbosity and the change takes effect from the next turn. */
+	setOutputModeByKey(key, mode) {
+		if (!this.store.getSession(key)) return;
+		this.store.setOutputModeOverride(key, mode);
+		this.log.info(`session ${key} output-mode override → "${mode}"`);
+		this.refreshStatusBarForKey(key);
+	}
 	/** 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 in-session effort switch (C→D `webchat/set-effort`). */
+	handleWebchatSetEffort(m) {
+		this.setEffortByKey(this.webchatSessionKey(m.conversationId, m.agentId), m.effort);
+	}
+	/** Handle a webchat in-session fast-mode toggle (C→D `webchat/set-fast`). */
+	handleWebchatSetFast(m) {
+		this.setFastByKey(this.webchatSessionKey(m.conversationId, m.agentId), m.fastMode);
+	}
 	/** 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. */
@@ -85278,11 +85592,20 @@ var Daemon = class Daemon {
 		}
 		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. */
+	/** Route a Slack status-bar Block Kit interaction (model / effort / fast select or the
+	*  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);
+		else if (a.kind === "set-model") {
+			if (a.model) this.setModelByKey(a.sessionKey, a.model);
+		} else if (a.kind === "set-effort") {
+			if (a.effort) this.setEffortByKey(a.sessionKey, a.effort);
+		} else if (a.kind === "set-fast") {
+			if (a.fastMode !== void 0) this.setFastByKey(a.sessionKey, a.fastMode);
+		} else if (a.kind === "set-output") {
+			if (a.outputMode) this.setOutputModeByKey(a.sessionKey, a.outputMode);
+		}
 	}
 	/** 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. */
@@ -85457,12 +85780,13 @@ var Daemon = class Daemon {
 			this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
 			return null;
 		}
-		const conv = new OutputConverger(this.agents.get(agentId).output.mode);
+		const agent = this.agents.get(agentId);
 		const rec = new TranscriptRecorder();
 		const replyConn = msg.headless || webchat ? void 0 : this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
 		const key = sessionKey(msg.platform, msg.channel, statusThread, agentId);
+		const conv = new OutputConverger(this.store.getOutputModeOverride(key) ?? agent.output.mode);
 		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…");
 		let handled;
 		try {
@@ -85506,6 +85830,10 @@ var Daemon = class Daemon {
 			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}`));
+			const effortOverride = this.store.getEffortOverride(key);
+			if (effortOverride) await host.setSessionEffort(sessionId, effortOverride).catch((err) => this.log.debug(`effort override "${effortOverride}" not applied: ${err.message}`));
+			const fastOverride = this.store.getFastModeOverride(key);
+			if (fastOverride !== void 0) await host.setSessionFastMode(sessionId, fastOverride).catch((err) => this.log.debug(`fast-mode override ${fastOverride} not applied: ${err.message}`));
 			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
 			this.emitStatusBar(p);
 			const { stopReason, usage } = await host.prompt(sessionId, blocks);
@@ -85685,11 +86013,16 @@ var Daemon = class Daemon {
 	statusInfoFrom(agentId, sessionKey, acpSessionId, opts = {}) {
 		const agent = this.agents.get(agentId);
 		const usage = this.store.getUsage(sessionKey);
-		const model = this.hosts.get(agentId)?.modelOptions?.();
+		const host = this.hosts.get(agentId);
+		const model = host?.modelOptions?.();
+		const effort = host?.effortOptions?.();
+		const fast = host?.fastModeOption?.();
+		const effortOverride = this.store.getEffortOverride(sessionKey);
+		const fastOverride = this.store.getFastModeOverride(sessionKey);
 		return {
 			model: model?.current ?? agent?.runtimeOverrides?.model,
-			effort: agent?.reasoningEffort,
-			fastMode: agent?.fastMode,
+			effort: effortOverride ?? effort?.current ?? agent?.reasoningEffort,
+			fastMode: fastOverride ?? fast?.current ?? agent?.fastMode,
 			contextUsed: usage.contextUsed,
 			contextSize: usage.contextSize,
 			totalTokens: usage.totalTokens,
@@ -85700,9 +86033,12 @@ var Daemon = class Daemon {
 				outputTokens: usage.outputTokens,
 				thoughtTokens: usage.thoughtTokens,
 				cachedReadTokens: usage.cachedReadTokens,
-				cachedWriteTokens: usage.cachedWriteTokens
+				cachedWriteTokens: usage.cachedWriteTokens,
+				outputMode: this.store.getOutputModeOverride(sessionKey) ?? agent?.output?.mode
 			} : {},
 			...model?.models?.length ? { models: model.models } : {},
+			...effort?.efforts?.length ? { efforts: effort.efforts } : {},
+			...fast ? { fastModeAvailable: true } : {},
 			...acpSessionId ? { sessionId: acpSessionId } : {}
 		};
 	}
@@ -86304,6 +86640,8 @@ var Daemon = class Daemon {
 			onWebchatMessage: (m) => this.handleWebchatMessage(m),
 			onWebchatClose: (m) => this.handleWebchatClose(m),
 			onWebchatSetModel: (m) => this.handleWebchatSetModel(m),
+			onWebchatSetEffort: (m) => this.handleWebchatSetEffort(m),
+			onWebchatSetFast: (m) => this.handleWebchatSetFast(m),
 			onWebchatCancel: (m) => this.handleWebchatCancel(m),
 			clock: systemClock,
 			connect: () => ClientTransport.dial(url),