@xmoon76/dsh-pi-tui 0.1.4 → 0.1.5

package/dist/index.mjs

@@ -29,6 +29,7 @@ import { eastAsianWidth } from "get-east-asian-width";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { EventEmitter } from "events";
+import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 //#region src/present.ts
 /** Figma row titles per variant (design literals, not translatable copy). */
 const VARIANT_TITLES = {
@@ -12623,8 +12624,9 @@ const OTHER_ROW = "\0other";
 /**
 * Default total physical-row budget of the question flow itself. The
 * QuestionFrame in tui-app.ts re-derives the budget from the terminal height
-* on every render (60% cap, 8..24 content rows) and pushes it through
-* {@link QuestionFlow.setMaxRows}; 24 is the fallback for direct renders.
+* on every render (60% cap COLLAPSED, 8..24 content rows; up to 38 when
+* expanded) and pushes it through {@link QuestionFlow.setMaxRows}; 24 is the
+* fallback for direct renders.
 * The Frame wrapper adds its two border rows, and NOTHING clips the flow's
 * output in the editor-seat layout — so EVERYTHING (tabs, question, detail,
 * options with their descriptions, scroll marker, skipped note, hint) must
@@ -12638,13 +12640,24 @@ const DEFAULT_BUDGET = 24;
 */
 const MIN_SUPPORTED_BUDGET = 8;
 /**
-* Total physical-row budget for the question body (question text + detail),
-* shared so a single unbroken long line cannot push the options and hints
-* out of the dialog's maxHeight (kimi MAX_BODY_LINES scale).
+* Largest supported content-row budget: the EXPANDED frame cap (80% of the
+* terminal, at most 40 frame rows) minus the two frame borders. An explicit
+* body expand ('e' / marker click) grows the panel beyond the default 60%
+* cap — the user asked for the room; the budget math is linear and holds
+* for every budget >= MIN_SUPPORTED_BUDGET.
 */
-const MAX_BODY_LINES = 12;
-/** Max visible option rows before the list windows around the cursor. */
-const MAX_VISIBLE_OPTIONS = 7;
+const MAX_BUDGET = 38;
+/**
+* Cap for the WRAPPED page scrollport content (question + detail + options
+* with their descriptions). Beyond it the content ends in a `... more
+* content hidden` note — wrapping an unbounded 100KB detail every frame
+* would be wasteful. 256 rows keeps realistic questions AND all their
+* answerable options reachable (7 options × ~19 wrapped description rows
+* at 50 columns fits); the cap is a hard wall, so a page whose content
+* alone exceeds 256 rows ends in the note — that page is unreachable in
+* practice, and the note makes the cut non-silent.
+*/
+const MAX_CONTENT_ROWS = 256;
 /**
 * Budgeted push of `content` to `lines`, wrapping it to `width`: pushes at
 * most `budget` PHYSICAL (wrapped) rows, appends a `... N more` marker when
@@ -12736,13 +12749,46 @@ var QuestionFlow = class {
 	/** Review-page action highlight (0 = Submit, 1 = Cancel). */
 	submitIdx = 0;
 	/**
-	* Current content-row budget (8..24). The editor-seat QuestionFrame in
+	* Current content-row budget (8..38). The editor-seat QuestionFrame in
 	* tui-app.ts re-derives it from the terminal height on every render and
 	* pushes it through {@link setMaxRows}; nothing clips the flow's output
 	* in that layout, so every render must fit the budget exactly.
 	*/
 	budget = DEFAULT_BUDGET;
 	_focused = false;
+	/**
+	* Scroll offset (content rows) into the UNIFIED page scrollport (question,
+	* detail, then every option with its description, then the free-text row).
+	* PageUp/PageDown move it; ↑↓/digits/click move the cursor and the render
+	* follows it into view (pendingCursorScroll).
+	*/
+	bodyScroll = 0;
+	/**
+	* Expanded mode ('e' / marker click): the FRAME grows toward 80% (the
+	* QuestionFrame reads isBodyExpanded each render), so the scrollport is
+	* taller and more of the page — including option descriptions — is visible
+	* at once. Everything stays reachable by scrolling either way.
+	*/
+	bodyExpanded = false;
+	/** Cursor moved since the last render: the next render must scroll the
+	* cursor's rows into view. */
+	pendingCursorScroll = false;
+	/** Hit map from the last render: content row -> option row key. Built each
+	* render; drives fullscreen click-to-select. */
+	hitMap = /* @__PURE__ */ new Map();
+	/** Content row of the scroll marker in the last render (-1 = none);
+	* clicking it toggles the expanded panel. */
+	lastMarkerRow = -1;
+	/** Scrollport height from the last render (scroll page math). */
+	lastRegionHeight = 0;
+	/** Wrapped page content length from the last render. */
+	lastContentRows = 0;
+	/** Content rows visible in the region from the last render (region minus
+	* the marker row when overflowing). */
+	lastVisibleRows = 0;
+	/** Whether the page content overflows the scrollport on the last render —
+	* 'e' (and the scroll verbs) are available when true. */
+	lastExpandable = false;
 	constructor(questions, onDone, onCancel) {
 		this.questions = questions;
 		this.onDone = onDone;
@@ -12773,10 +12819,144 @@ var QuestionFlow = class {
 	* Replace the content-row budget (the Frame wrapper adds its two border
 	* rows on top). Called by QuestionFrame on every render immediately
 	* before the flow renders, so no invalidation is needed; values outside
-	* [MIN_SUPPORTED_BUDGET, DEFAULT_BUDGET] are clamped.
+	* [MIN_SUPPORTED_BUDGET, MAX_BUDGET] are clamped.
 	*/
 	setMaxRows(rows) {
-		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(DEFAULT_BUDGET, Math.floor(rows)));
+		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(MAX_BUDGET, Math.floor(rows)));
+	}
+	/** Whether the panel is expanded (the frame grows toward 80% of the
+	* terminal — QuestionFrame reads this every render). */
+	isBodyExpanded() {
+		return this.bodyExpanded;
+	}
+	/**
+	* Reset the view (scroll + expanded + pending cursor follow) — called on
+	* every tab change so each question starts at its top, collapsed.
+	*/
+	resetBodyView() {
+		this.bodyScroll = 0;
+		this.bodyExpanded = false;
+		this.pendingCursorScroll = false;
+	}
+	/**
+	* Page the unified scrollport. One page = the visible content rows. No-op
+	* when the content fits the region.
+	*/
+	scrollBody(direction) {
+		const visible = this.lastVisibleRows;
+		if (visible <= 0 || this.lastContentRows <= visible) return;
+		const maxScroll = this.lastContentRows - visible;
+		this.bodyScroll = Math.max(0, Math.min(this.bodyScroll + direction * visible, maxScroll));
+	}
+	/** Toggle the expanded panel ('e' or a click on the scroll marker).
+	* Expanding is only meaningful when the page content overflows the
+	* scrollport (everything fits -> a taller panel shows nothing new). The
+	* SCROLL POSITION is kept: the taller region reveals MORE rows where the
+	* user is looking (e.g. the option descriptions they scrolled to), instead
+	* of jumping back to the top — the render clamps the offset to the new
+	* maxScroll. */
+	toggleExpanded() {
+		if (!this.bodyExpanded && !this.lastExpandable) return;
+		this.bodyExpanded = !this.bodyExpanded;
+	}
+	/**
+	* Primary-click routing (fullscreen): an option row selects it (single-
+	* select advances, multi-select toggles, the "Type something." row enters
+	* free-text), and the scroll marker toggles the expanded panel. The hit
+	* map reflects the LAST rendered frame, which is what the user sees.
+	*/
+	clickRow(row) {
+		if (row < 0 || this.tab >= this.questions.length) return;
+		const key = this.hitMap.get(row);
+		if (key === OTHER_ROW) {
+			if (this.editingOther) return;
+			const index = this.rows().findIndex((candidate) => candidate.key === OTHER_ROW);
+			if (index >= 0) {
+				this.cursor = index;
+				this.pendingCursorScroll = true;
+				this.enterOther();
+			}
+			return;
+		}
+		if (key !== void 0) {
+			this.cursor = Number(key);
+			this.pendingCursorScroll = true;
+			this.confirm();
+			return;
+		}
+		if (row === this.lastMarkerRow) this.toggleExpanded();
+	}
+	/**
+	* Build the UNIFIED page scrollport content: the question + detail first
+	* (required-first — row 0 is always the question's first physical row),
+	* a separator, then every option row (label + description), then the
+	* free-text row. Each option row maps to its key for click hit-testing.
+	* Capped at MAX_CONTENT_ROWS with a trailing `... more content hidden`
+	* note, so wrapping an unbounded detail/description stays cheap.
+	*/
+	buildPageContent(question, rows, draft, multi, width) {
+		const lines = [];
+		const hits = [];
+		let left = MAX_CONTENT_ROWS;
+		left = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), width, left);
+		hits.push(...new Array(lines.length).fill(void 0));
+		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
+			if (left <= 1) {
+				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), width, left);
+				break;
+			}
+			left = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), width, left);
+		}
+		hits.push(...new Array(lines.length - hits.length).fill(void 0));
+		lines.push("");
+		hits.push(void 0);
+		for (const row of rows) {
+			const isCursor = rows[this.cursor] === row;
+			const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
+			const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
+			const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
+			const indent = " ".repeat(visibleWidth(prefix));
+			const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
+			const label = isCursor ? color.textStrong(row.label) : row.label;
+			if (row.key === OTHER_ROW && this.editingOther) {
+				const inputLine = this.otherInput.render(Math.max(1, width - visibleWidth(prefix)))[0] ?? "";
+				const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+				lines.push(prefix + (this.otherInput.getValue() === "" ? color.textDim(row.label) : stripped));
+				hits.push(OTHER_ROW);
+				continue;
+			}
+			const labelWidth = Math.max(1, width - visibleWidth(prefix));
+			for (const wrapped of wrapTextWithAnsi(`${label}${badge}`, labelWidth)) if (!this.pushPageRow(lines, hits, prefix + wrapped, row.key)) return {
+				lines,
+				hits
+			};
+			if (row.description !== void 0 && row.description !== "" && !(row.key === OTHER_ROW && this.editingOther)) {
+				const descWidth = Math.max(1, width - visibleWidth(indent));
+				for (const wrapped of wrapTextWithAnsi(color.textDim(row.description), descWidth)) if (!this.pushPageRow(lines, hits, indent + wrapped, row.key)) return {
+					lines,
+					hits
+				};
+			}
+		}
+		return {
+			lines,
+			hits
+		};
+	}
+	/** Push one page-content row, capping at MAX_CONTENT_ROWS with a single
+	* `... more content hidden` note (never a second one after the detail's).
+	* @returns false when the cap was hit (callers stop building). */
+	pushPageRow(lines, hits, line, key) {
+		if (lines.length >= MAX_CONTENT_ROWS) {
+			if (lines[lines.length - 1]?.includes("more content hidden") !== true) {
+				lines.push(color.textDim("... more content hidden"));
+				hits.push(void 0);
+			}
+			return false;
+		}
+		lines.push(line);
+		hits.push(key);
+		return true;
 	}
 	/** The rows of the current question (options plus the free-text row). */
 	rows() {
@@ -12846,6 +13026,7 @@ var QuestionFlow = class {
 	}
 	/** Optionless questions edit text directly; options start in list mode. */
 	syncEditMode() {
+		this.resetBodyView();
 		const question = this.questions[this.tab];
 		const optionless = question !== void 0 && (question.options?.length ?? 0) === 0;
 		this.editingOther = optionless;
@@ -12920,6 +13101,7 @@ var QuestionFlow = class {
 		if (this.editingOther) {
 			if (data === "\r" || data === "\n") this.commitOther(this.otherInput.getValue());
 			else if (data === "\x1B") this.exitOther();
+			else if (data === "\x1B[5~" || data === "\x1B[6~") this.scrollBody(data === "\x1B[5~" ? -1 : 1);
 			else if (data === "\x1B[D") {
 				if (this.tab > 0) {
 					this.tab -= 1;
@@ -12962,16 +13144,27 @@ var QuestionFlow = class {
 			const row = rows[Number(digit[0]) - 1];
 			if (row !== void 0) {
 				this.cursor = rows.indexOf(row);
+				this.pendingCursorScroll = true;
 				this.confirm();
 			}
 			return;
 		}
 		if (data === "\x1B[A" || data === "k") {
 			if (rows.length > 0) this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+			this.pendingCursorScroll = true;
 			return;
 		}
 		if (data === "\x1B[B" || data === "j") {
 			if (rows.length > 0) this.cursor = (this.cursor + 1) % rows.length;
+			this.pendingCursorScroll = true;
+			return;
+		}
+		if (data === "\x1B[5~" || data === "\x1B[6~") {
+			this.scrollBody(data === "\x1B[5~" ? -1 : 1);
+			return;
+		}
+		if (data === "e") {
+			this.toggleExpanded();
 			return;
 		}
 		if (data === "\r" || data === "\n") {
@@ -12992,6 +13185,7 @@ var QuestionFlow = class {
 				this.tab += 1;
 				this.cursor = 0;
 				this.submitIdx = 0;
+				this.syncEditMode();
 			} else {
 				this.tab = this.questions.length;
 				this.cursor = 0;
@@ -13012,6 +13206,8 @@ var QuestionFlow = class {
 	render(width) {
 		const safeWidth = Math.max(1, width);
 		const lines = [];
+		this.hitMap.clear();
+		this.lastMarkerRow = -1;
 		const tabs = this.questions.map((_, index) => {
 			const draft = this.drafts[index];
 			const answered = draft !== void 0 && (draft.selected.size > 0 || draft.custom !== "" || draft.skipped);
@@ -13053,102 +13249,73 @@ var QuestionFlow = class {
 		if (question === void 0 || draft === void 0) return lines;
 		const rows = this.rows();
 		const multi = question.multiSelect === true;
-		this.editingOther && rows.some((row) => row.key === OTHER_ROW);
 		const skippedRow = draft.skipped ? 1 : 0;
 		const optionless = rows.length === 0 || rows.length === 1 && rows[0]?.key === OTHER_ROW;
-		const tail = optionless ? 3 + skippedRow : 4 + skippedRow;
-		let bodyAllowance = this.budget - lines.length - tail;
+		const tail = optionless ? 3 + skippedRow : 2 + skippedRow;
 		const header = question.header;
-		if (header !== void 0 && header !== "" && bodyAllowance >= 2) {
-			lines.push(color.textDim(header));
-			bodyAllowance -= 1;
-		}
-		const bodyBudget = Math.min(MAX_BODY_LINES, Math.max(1, bodyAllowance));
-		let bodyLeft = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), safeWidth, bodyBudget);
-		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
-			if (bodyLeft <= 1) {
-				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), safeWidth, bodyLeft);
-				break;
-			}
-			bodyLeft = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), safeWidth, bodyLeft);
-		}
-		if (!optionless) {
-			lines.push("");
-			const optionBudget = this.budget - lines.length - skippedRow - 2;
-			const maxWindow = Math.max(1, Math.min(MAX_VISIBLE_OPTIONS, optionBudget));
-			const visibleCount = Math.min(rows.length, maxWindow);
-			const half = Math.floor(maxWindow / 2);
-			const maxStart = Math.max(0, rows.length - visibleCount);
-			const start = Math.max(0, Math.min(this.cursor - half, maxStart));
-			const end = Math.min(rows.length, start + visibleCount);
-			{
-				const cursorRow = rows[this.cursor];
-				let reserved = 1;
-				if (cursorRow !== void 0 && cursorRow.key !== OTHER_ROW) {
-					const prefix = `→ ${multi || cursorRow.key === OTHER_ROW ? draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? "[✓]" : "[ ]" : draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? `[${Number(cursorRow.key) + 1}]` : `[${Number(cursorRow.key) + 1}]`} `;
-					const badge = cursorRow.recommended ? ` ${color.primary("[recommended]")}` : "";
-					reserved = Math.min(Math.max(1, wrapTextWithAnsi(`${color.textStrong(cursorRow.label)}${badge}`, Math.max(1, safeWidth - visibleWidth(prefix))).length), maxWindow);
-				}
-				let left = optionBudget;
-				let cursorRendered = false;
-				for (let index = start; index < end; index++) {
-					const row = rows[index];
-					if (row === void 0) continue;
-					const isCursor = index === this.cursor;
-					if (!isCursor && (cursorRendered ? left <= 0 : left <= reserved)) continue;
-					if (row.key === OTHER_ROW && this.editingOther) {
-						const prefix = `${color.primary("→")} ${color.textDim(`[${index + 1}]`)} `;
-						const inputLine = this.otherInput.render(Math.max(1, safeWidth - visibleWidth(prefix)))[0] ?? "";
-						const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-						left -= 1;
-						lines.push(prefix + stripped);
-						if (isCursor) cursorRendered = true;
-						continue;
-					}
-					const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
-					const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
-					const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
-					const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
-					const label = isCursor ? color.textStrong(row.label) : row.label;
-					const indent = " ".repeat(visibleWidth(prefix));
-					const available = isCursor || cursorRendered ? left : left - reserved;
-					const beforeLabel = lines.length;
-					if (isCursor) appendContentFirst(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					else appendWrappedBudgeted(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					left -= lines.length - beforeLabel;
-					if (row.description !== void 0 && row.description !== "" && left > 0) {
-						const descCap = isCursor || cursorRendered ? left : left - reserved;
-						const beforeDescription = lines.length;
-						appendWrappedBudgeted(lines, indent, indent, color.textDim(row.description), safeWidth, descCap);
-						left -= lines.length - beforeDescription;
-					}
-					if (isCursor) cursorRendered = true;
+		if (header !== void 0 && header !== "" && this.budget - lines.length - tail >= 2) lines.push(color.textDim(header));
+		const content = this.buildPageContent(question, rows, draft, multi, safeWidth);
+		const regionHeight = Math.max(1, this.budget - lines.length - tail);
+		const overflow = content.lines.length > regionHeight;
+		const visible = overflow && regionHeight >= 2 ? regionHeight - 1 : regionHeight;
+		this.lastRegionHeight = regionHeight;
+		this.lastContentRows = content.lines.length;
+		this.lastVisibleRows = visible;
+		this.lastExpandable = overflow && regionHeight >= 2;
+		const maxScroll = Math.max(0, content.lines.length - visible);
+		this.bodyScroll = Math.min(this.bodyScroll, maxScroll);
+		if (this.pendingCursorScroll) {
+			this.pendingCursorScroll = false;
+			const cursorKey = rows[this.cursor]?.key;
+			if (cursorKey !== void 0) {
+				const first = content.hits.indexOf(cursorKey);
+				if (first >= 0) {
+					if (first < this.bodyScroll) this.bodyScroll = first;
+					else if (first >= this.bodyScroll + visible) this.bodyScroll = first - visible + 1;
+					this.bodyScroll = Math.max(0, Math.min(this.bodyScroll, maxScroll));
 				}
-				if (rows.length > MAX_VISIBLE_OPTIONS && left > 0) left = appendWrappedBudgeted(lines, "   ", "   ", `showing ${start + 1}-${end} of ${rows.length}`, safeWidth, left);
 			}
-		} else {
+		}
+		for (let index = this.bodyScroll; index < this.bodyScroll + visible && index < content.lines.length; index++) {
+			const hit = content.hits[index];
+			if (hit !== void 0) this.hitMap.set(lines.length, hit);
+			lines.push(content.lines[index]);
+		}
+		if (overflow && regionHeight >= 2) {
+			const above = this.bodyScroll;
+			const below = content.lines.length - (this.bodyScroll + visible);
+			const marker = above > 0 && below > 0 ? `↑ ${above} up · ↓ ${below} more lines` : above > 0 ? `↑ ${above} up` : `↓ ${below} more lines`;
+			this.lastMarkerRow = lines.length;
+			lines.push(color.textDim(marker));
+		} else this.lastMarkerRow = -1;
+		if (optionless) {
 			const inputLine = this.otherInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
 			const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-			lines.push(` ${stripped}`);
+			lines.push(this.otherInput.getValue() === "" ? color.textDim(" Type your answer…") : ` ${stripped}`);
 		}
 		if (draft.skipped) lines.push(color.textDim("(skipped)"));
 		lines.push("");
 		const optionCount = Math.min(rows.length, 9);
+		const scrollable = this.lastExpandable;
 		const hintParts = [
 			"↑↓ select",
 			optionCount > 0 ? `1-${optionCount} choose` : "",
 			multi ? "↵ toggle" : "↵ confirm",
+			scrollable ? "pgup/pgdn scroll" : "",
+			!this.editingOther ? this.bodyExpanded ? "e collapse" : scrollable ? "e expand" : "" : "",
 			this.questions.length > 1 ? "←→ switch" : "",
 			"s skip",
 			"esc cancel"
 		].filter((part) => part !== "");
+		const cancel = "esc cancel";
+		const verbs = hintParts.filter((part) => part !== cancel);
 		let hint = "";
-		for (const part of hintParts) {
+		for (const part of verbs) {
 			const next = hint === "" ? part : `${hint} · ${part}`;
-			if (visibleWidth(next) > safeWidth) break;
+			if (visibleWidth(`${next} · ${cancel}`) > safeWidth) break;
 			hint = next;
 		}
-		lines.push(color.textDim(hint === "" ? "esc cancel" : hint));
+		lines.push(color.textDim(hint === "" ? cancel : `${hint} · ${cancel}`));
 		return lines;
 	}
 };
@@ -13705,6 +13872,10 @@ var Frame = class {
 var QuestionFrame = class extends Frame {
 	flow;
 	heightOf;
+	/** Rendered height of the last frame (fullscreen click hit-testing). */
+	lastRows = 0;
+	/** Terminal height the last render used (click staleness guard). */
+	lastTermRows = 0;
 	constructor(flow, heightOf) {
 		super(flow, true);
 		this.flow = flow;
@@ -13712,9 +13883,20 @@ var QuestionFrame = class extends Frame {
 	}
 	render(width) {
 		const rows = Math.max(1, this.heightOf());
-		const frameRows = Math.max(10, Math.min(26, Math.floor(rows * .6)));
+		this.lastTermRows = rows;
+		const frameRows = this.flow.isBodyExpanded() ? Math.max(10, Math.min(40, Math.floor(rows * .8))) : Math.max(10, Math.min(26, Math.floor(rows * .6)));
 		this.flow.setMaxRows(frameRows - 2);
-		return super.render(width);
+		const out = super.render(width);
+		this.lastRows = out.length;
+		return out;
+	}
+	/** The frame's height from the last render (0 before the first one). */
+	get rows() {
+		return this.lastRows;
+	}
+	/** The terminal height the last render used. */
+	get termRows() {
+		return this.lastTermRows;
 	}
 	get focused() {
 		return this.flow.focused;
@@ -14714,6 +14896,23 @@ var TuiApp = class TuiApp {
 	* The global Ctrl+O fold still wins, so keyboard behavior is unchanged.
 	*/
 	handleFullscreenClick(x, y) {
+		const question = this.activeQuestions;
+		if (question?.frame !== void 0) {
+			if (this.terminal.rows !== question.frame.termRows) return;
+			const width = this.terminal.columns;
+			const height = this.terminal.rows;
+			const footerHeight = this.footer.render(width).length;
+			const seatHeight = question.frame.rows;
+			const seatBottom = height - footerHeight;
+			const seatTop = seatBottom - seatHeight;
+			if (y >= seatTop && y < seatBottom) {
+				if (x >= 2 && x <= width - 3) {
+					question.flow.clickRow(y - seatTop - 1);
+					this.requestRender();
+				}
+				return;
+			}
+		}
 		const width = this.terminal.columns;
 		const rowInScroll = y - this.header.render(width).length;
 		if (rowInScroll < 0) return;
@@ -16240,6 +16439,262 @@ async function loadSessionTitles(query, persistence, ids, signal) {
 	return titles;
 }
 //#endregion
+//#region src/skill-catalog.ts
+/**
+* The standing-scope skill catalog adapter: the SINGLE narrow seam between
+* the TUI and the dsh skill services (the non-public-API isolation
+* contract, plan appendix B).
+*
+* Everything the TUI knows about dsh-skill and agent-presets lives here:
+* - structural service types (never upstream classes) with OPTIONAL
+*   capability members — `snapshot` and `standingKeyFor` are detected at
+*   call time, so an upstream change degrades instead of breaking;
+* - `readHumanSkillCatalog()`: snapshot-first collector (list() fallback),
+*   official `isUserInvocable` filter, field validation, stable sort,
+*   deep freeze, distinct abort propagation;
+* - `resolveColdSkillTarget()`: capability-gated cold target selection
+*   (standing scope → rosterless global → degraded global with a notice);
+* - `resolveLiveSkillTarget()`: the agent's own registry + agent scope.
+*
+* Failure contract: ordinary provider/composition failures surface as
+* degraded targets or rethrown errors for the coordinator to classify;
+* aborts ALWAYS propagate as aborts. No failure may hang or crash the TUI —
+* the worst outcome is "the corresponding commands are missing".
+* @module @xmoon76/dsh-pi-tui/skill-catalog
+*/
+/**
+* Subscribe to the dsh-skill invalidation notification. The event carries
+* no scope or cwd — consumers refetch for their own cwd and scope — and the
+* subscription itself is optional: an unavailable `on` or a throwing
+* subscribe degrades to NO subscription (owner switches and `/reload` still
+* refresh). The CALLER owns the listener's failure totality (route the
+* refresh through `runOwned`).
+* @param ctx - the context surface exposing the event bus.
+* @param listener - the notification listener (must be synchronous and
+*   never throw).
+*/
+function subscribeSkillsChange(ctx, listener) {
+	ctx.on?.("skills/change", listener);
+}
+/**
+* Whether one summary passes the OFFICIAL user-invocation policy — the
+* adapter's exported guard, used by every human entry point (direct
+* wrappers, `/skill`, the picker, and final body loads). A malformed
+* `invocation` (missing, non-object, non-boolean flag) is treated as NOT
+* user-invocable: the policy defaults are never reinterpreted, and a
+* hostile entry can neither throw nor sneak into a human surface.
+*/
+function isUserInvocableSkill(skill) {
+	const invocation = skill.invocation;
+	if (typeof invocation !== "object" || invocation === null) return false;
+	if (typeof invocation.userInvocable !== "boolean") return false;
+	return isUserInvocable(skill);
+}
+/** Copy one summary, keeping ONLY the supported display fields. An entry
+* with a non-string name or description is rejected (never copied, never
+* trusted); a non-string `whenToUse` is dropped. */
+function toHumanSummary(skill) {
+	if (typeof skill.name !== "string" || skill.name === "") return void 0;
+	if (typeof skill.description !== "string") return void 0;
+	return Object.freeze({
+		name: skill.name,
+		description: skill.description,
+		...typeof skill.whenToUse === "string" && skill.whenToUse !== "" ? { whenToUse: skill.whenToUse } : {}
+	});
+}
+/** Whether one summary passes the OFFICIAL user-invocation policy. A
+* malformed `invocation` (missing, non-object, non-boolean flag) is treated
+* as NOT user-invocable — the policy defaults are never reinterpreted, and
+* a hostile entry can neither throw nor sneak into the human catalog. */
+function userInvocable(skill) {
+	return isUserInvocableSkill(skill);
+}
+/**
+* Read one human skill catalog from a registry: snapshot-first, official
+* policy filter, validated detached copies, stable name sort, deep freeze.
+* @param registry - the registry to read (the adapter's structural type).
+* @param options - cwd/scope/signal for the read.
+* @returns the detached catalog.
+* @throws on cancellation (ALWAYS, distinctly) and on non-abort read
+*   failures (the coordinator classifies them: retain last-good + diag).
+*/
+async function readHumanSkillCatalog(registry, options) {
+	options.signal?.throwIfAborted();
+	const observed = typeof registry.snapshot === "function" ? await registry.snapshot(options) : {
+		skills: await registry.list?.(options) ?? [],
+		complete: true
+	};
+	options.signal?.throwIfAborted();
+	const skills = observed.skills.filter(userInvocable).map(toHumanSummary).filter((summary) => summary !== void 0).sort((left, right) => left.name < right.name ? -1 : 1);
+	return Object.freeze({
+		skills: Object.freeze(skills),
+		complete: observed.complete === true
+	});
+}
+/**
+* Resolve the COLD (sessionless) skill target with capability detection:
+* - a preset roster with `standingKeyFor` → the standing scope of the
+*   effective preset;
+* - no roster / no `standingKeyFor` / a standing resolution failure → the
+*   global layer (with a one-shot degradation notice on failure);
+* - no skill registry at all → no target (nothing to read, no notice).
+* @param ctx - the context surface.
+* @param presetId - the effective preset id, or undefined for the default.
+* @param cwd - the workspace cwd for provider selection.
+*/
+async function resolveColdSkillTarget(ctx, presetId, cwd) {
+	const registry = ctx.get("skills");
+	if (registry === void 0) return {};
+	const presets = ctx.get("agentPresets");
+	if (presets === void 0 || typeof presets.standingKeyFor !== "function") return { target: {
+		kind: "cold-global",
+		registry,
+		cwd,
+		scope: void 0
+	} };
+	try {
+		return { target: {
+			kind: "cold-standing",
+			registry,
+			cwd,
+			scope: await presets.standingKeyFor(presetId)
+		} };
+	} catch (error) {
+		const message = safeErrorMessage(error);
+		return {
+			target: {
+				kind: "cold-global",
+				registry,
+				cwd,
+				scope: void 0
+			},
+			degraded: `skill catalog unavailable for preset "${presetId ?? "default"}": ${message}`
+		};
+	}
+}
+/**
+* Resolve the LIVE skill target: the registry the agent actually sees
+* (its preset's scoped instance when the preset mounts one, else the host
+* registry), with the AGENT OBJECT as the view scope.
+* @param ctx - the context surface.
+* @param agent - the live agent.
+* @param cwd - the session workspace cwd.
+* @returns the live target, or undefined when no registry is reachable.
+*/
+function resolveLiveSkillTarget(ctx, agent, cwd) {
+	const registry = ctx.get("agentPresets")?.serviceFor?.(agent, "skills") ?? ctx.get("skills");
+	if (registry === void 0) return void 0;
+	return {
+		kind: "live",
+		registry,
+		cwd,
+		scope: agent
+	};
+}
+//#endregion
+//#region src/surface-catalog.ts
+/**
+* The in-process global-layer command view. The public type requires an
+* `Agent`, but `commands.list(undefined)` resolves the global layer only
+* (ScopedLayers merges no overlays for an undefined key); the current TUI
+* already depends on this in-process behavior. The cast is isolated HERE so
+* the undefined key never reaches a remote RPC path, and the helper is the
+* single seam to replace if upstream ever ships a typed global-list API.
+* @param commands - the commands service.
+* @returns the global-layer descriptors (name-sorted by the registry).
+*/
+function listGlobalCommands(commands) {
+	return commands.list(void 0);
+}
+/** Copy one descriptor into a fresh frozen summary (never borrowed). */
+function commandSummaryOf(descriptor) {
+	return Object.freeze({
+		name: descriptor.name,
+		description: descriptor.description,
+		...descriptor.input === void 0 ? {} : { input: Object.freeze({ hint: descriptor.input.hint }) }
+	});
+}
+/** Whether two descriptors expose identical display fields (origin-blind:
+* an identical scoped entry needs no override because the visible result and
+* the real-agent execution are the same either way). */
+function sameCommand(left, right) {
+	return left.name === right.name && left.description === right.description && left.input?.hint === right.input?.hint;
+}
+/**
+* Read one agent's effective surface catalog: global + scoped commands and
+* human-invocable skills, fully detached and frozen.
+*
+* Provider isolation (per the probe contract):
+* - lifecycle/refresh cancellation terminates the WHOLE read and propagates;
+* - an ordinary provider failure empties only that field and records a
+*   detached issue; other providers continue;
+* - a missing service is that provider's successful empty result (no issue).
+*
+* This function only READS: it registers nothing, mutates nothing, and never
+* touches a runner's live agent. Probe and live agent share this collector
+* so the two surfaces cannot drift apart.
+* @param agent - the agent whose effective view to read.
+* @param signal - lifecycle/refresh cancellation.
+* @param ctx - the context surface resolving the services.
+* @returns a frozen, detached snapshot.
+*/
+async function readSurfaceCatalog(agent, signal, ctx) {
+	signal.throwIfAborted();
+	const issues = [];
+	let commands = [];
+	let scopedCommands = [];
+	const commandsService = ctx.get("commands");
+	if (commandsService !== void 0) try {
+		const global = listGlobalCommands(commandsService);
+		const globalBy = new Map(global.map((descriptor) => [descriptor.name, descriptor]));
+		const effective = commandsService.list(agent);
+		const scoped = [];
+		for (const descriptor of effective) {
+			const summary = commandSummaryOf(descriptor);
+			const baseline = globalBy.get(descriptor.name);
+			if (baseline === void 0 || !sameCommand(descriptor, baseline)) scoped.push(summary);
+		}
+		commands = sortCommands(effective.map(commandSummaryOf));
+		scopedCommands = sortCommands(scoped);
+	} catch (error) {
+		issues.push({
+			provider: "commands",
+			message: safeErrorMessage(error)
+		});
+	}
+	let skills = [];
+	const skillTarget = resolveLiveSkillTarget(ctx, agent, agent.session.header.cwd ?? process.cwd());
+	if (skillTarget !== void 0) try {
+		signal.throwIfAborted();
+		const catalog = await readHumanSkillCatalog(skillTarget.registry, {
+			cwd: skillTarget.cwd,
+			scope: skillTarget.scope,
+			signal
+		});
+		skills = catalog.skills;
+		if (catalog.complete !== true) issues.push({
+			provider: "skills",
+			message: "incomplete skill observation"
+		});
+	} catch (error) {
+		if (signal.aborted) throw error;
+		issues.push({
+			provider: "skills",
+			message: safeErrorMessage(error)
+		});
+	}
+	return Object.freeze({
+		commands,
+		scopedCommands,
+		skills,
+		issues: Object.freeze(issues.map((issue) => Object.freeze({ ...issue })))
+	});
+}
+/** Name-stable sort for command summaries (copies, never mutates input). */
+function sortCommands(commands) {
+	return Object.freeze([...commands].sort((left, right) => left.name < right.name ? -1 : 1));
+}
+//#endregion
 //#region src/commands.ts
 /**
 * The TUI-owned slash commands (/exit /settings /sessions /skill /model
@@ -16317,11 +16772,16 @@ function presetDisplayText(preset) {
 * commands appear in the editor's tab list. Registration is sessionless:
 * the commands service's global layer needs no agent, so the whole surface
 * is available before the first session exists (deferred start).
+*
+* When an `initial` catalog was prefetched (resume snapshot or cold
+* standing-scope skills), it installs SYNCHRONOUSLY at the end of
+* registration — direct skill wrappers plus the completion merge — so the
+* first input is served by the complete catalog with zero async I/O in
+* between.
 * @param runner - the live runner surface.
-* @returns a hook that rebuilds the per-skill slash commands (a no-op until
-*   the first session exists, since the skill catalog scope is the agent).
+* @param initial - optional prefetched catalogs installed synchronously.
 */
-function registerTuiCommands(runner) {
+function registerTuiCommands(runner, initial) {
 	const { ctx, app } = runner;
 	const cwd = runner.cwd;
 	const signal = runner.signal;
@@ -16365,12 +16825,60 @@ function registerTuiCommands(runner) {
 		if (agent === void 0) throw new Error("session could not be created");
 		return agent;
 	};
-	const refreshCompletions = () => {
-		app.setCommandCompletions(commands.list(runner.liveAgent).map((command) => ({
+	/** The advertised names of the currently installed completion list. */
+	let claims = /* @__PURE__ */ new Set();
+	/**
+	* Install one completion list (sorted, claims refreshed). The single
+	* synchronous seam every catalog commit funnels through.
+	*/
+	const installCompletions = (entries) => {
+		const sorted = [...entries].sort((left, right) => left.name < right.name ? -1 : 1);
+		app.setCommandCompletions(sorted.map((command) => ({
 			name: command.name,
 			description: command.description,
 			argumentHint: command.input?.hint
 		})), runner.sessionCwd(), fdPath);
+		claims = new Set(sorted.map((command) => command.name));
+	};
+	/** The saved probed scoped overrides (see installSurfaceSnapshot). */
+	let savedScopedCommands = [];
+	/**
+	* The sessionless completion view: the CURRENT global layer (fresh read —
+	* TUI built-ins, global plugins and installed skill wrappers all flow in)
+	* overlaid with the saved scoped overrides from the latest snapshot.
+	*/
+	const mergeGlobalAndSavedScoped = () => {
+		const byName = /* @__PURE__ */ new Map();
+		for (const descriptor of listGlobalCommands(commands)) byName.set(descriptor.name, commandSummaryOf(descriptor));
+		for (const scoped of savedScopedCommands) byName.set(scoped.name, scoped);
+		return [...byName.values()];
+	};
+	/**
+	* Refresh completions from the registry: the LIVE agent's effective view
+	* when one exists (global + its scoped shadows), else the global layer
+	* overlaid with the saved scoped overrides (sessionless merge). The agent
+	* may be undefined before the first session exists: in-process
+	* `commands.list(undefined)` safely returns the global layer only (the
+	* remote RPC path's lookup guard does not apply in-process).
+	*/
+	const refreshCompletions = () => {
+		const liveAgent = runner.liveAgent;
+		installCompletions(liveAgent === void 0 ? mergeGlobalAndSavedScoped() : commands.list(liveAgent).map(commandSummaryOf));
+	};
+	let commandCommitDepth = 0;
+	let commandCommitDirty = false;
+	/** Run one bulk command commit; registry changes inside are coalesced. */
+	const withCommandCommit = (phase) => {
+		commandCommitDepth += 1;
+		try {
+			phase();
+		} finally {
+			commandCommitDepth -= 1;
+			if (commandCommitDepth === 0 && commandCommitDirty) {
+				commandCommitDirty = false;
+				refreshCompletions();
+			}
+		}
 	};
 	refreshCompletions();
 	const exitHandler = () => {
@@ -16633,29 +17141,44 @@ function registerTuiCommands(runner) {
 			return openSessionPicker(invocation, "resume");
 		}
 	});
-	const skillService = (agent) => {
-		return ctx.get("agentPresets")?.serviceFor(agent, "skills") ?? ctx.get("skills");
-	};
 	/** The workspace the live session runs in; fallback to the TUI's cwd. */
 	const sessionCwd = (agent) => agent.session.header.cwd ?? cwd;
+	const skillTarget = (agent) => resolveLiveSkillTarget(ctx, agent, sessionCwd(agent));
+	/**
+	* The execution boundary for loading one skill into the live session;
+	* shared by /skill and the per-skill slash commands. The skill is fetched
+	* from the CURRENT agent's registry and its invocation policy is RE-CHECKED
+	* here — a summary that passed the cold/live filter is never execution
+	* authorization. A model-only skill is refused with an explicit error and
+	* never injected.
+	*/
 	const loadSkill = async (agent, name) => {
-		const skills = skillService(agent);
-		if (skills === void 0) return {
+		const target = skillTarget(agent);
+		if (target === void 0) return {
 			kind: "error",
 			text: "skill service unavailable"
 		};
-		const skill = await skills.get(name, {
-			cwd: sessionCwd(agent),
-			scope: agent
+		const skill = await target.registry.get?.(name, {
+			cwd: target.cwd,
+			scope: target.scope
 		});
 		if (skill === void 0) return {
 			kind: "error",
 			text: "unknown skill \"" + name + "\""
 		};
+		if (!isUserInvocableSkill(skill)) return {
+			kind: "error",
+			text: `skill "${name}" is not invocable by the user`
+		};
+		if (typeof skill.name !== "string" || skill.name === "" || typeof skill.description !== "string") return {
+			kind: "error",
+			text: `skill "${name}" returned a malformed definition`
+		};
+		const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
 		agent.inject(createUserMessage({
 			content: [{
 				type: "text",
-				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + (skill.content ?? skill.description)
+				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + body
 			}],
 			source: {
 				kind: "plugin",
@@ -16668,21 +17191,30 @@ function registerTuiCommands(runner) {
 		};
 	};
 	const skillDisposers = /* @__PURE__ */ new Map();
-	const registerSkillCommands = async () => {
-		const generation = runner.sessionGeneration;
+	/**
+	* Synchronously replace every direct skill wrapper from a snapshot. Pure
+	* install: no catalog fetch, no await — the callers (the initial snapshot
+	* commit, the live refresh, the coordinator) provide the data. The target
+	* set is computed FIRST (current global/effective view minus the wrappers
+	* this surface owns, plus the snapshot's scoped overrides), then the old
+	* wrappers are disposed and the new ones registered in one synchronous
+	* commit.
+	* @param skills - the human-invocable summaries to install.
+	* @param scopedNames - the snapshot's scoped command names: a preset-scoped
+	*   command must block a same-name wrapper even though the global view
+	*   cannot see it yet (sessionless install).
+	* @returns the number of wrappers installed.
+	*/
+	const replaceSkillCommands = (skills, scopedNames) => {
+		const owned = new Set(skillDisposers.keys());
+		const taken = /* @__PURE__ */ new Set();
+		const view = commands.list(runner.liveAgent);
+		for (const command of view) if (!owned.has(command.name)) taken.add(command.name);
+		for (const name of scopedNames) taken.add(name);
 		for (const dispose of skillDisposers.values()) dispose();
 		skillDisposers.clear();
-		const liveAgent = runner.liveAgent;
-		if (liveAgent === void 0) return 0;
-		const skills = skillService(liveAgent);
-		if (skills === void 0) return 0;
-		const taken = new Set(commands.list(liveAgent).map((command) => command.name));
-		const catalog = await skills.list({
-			cwd: sessionCwd(liveAgent),
-			scope: liveAgent
-		});
-		if (generation !== runner.sessionGeneration) return 0;
-		for (const skill of catalog) {
+		let count = 0;
+		for (const skill of skills) {
 			if (taken.has(skill.name)) continue;
 			try {
 				const dispose = commands.register({
@@ -16694,34 +17226,83 @@ function registerTuiCommands(runner) {
 					}
 				});
 				skillDisposers.set(skill.name, dispose);
+				count += 1;
 			} catch {}
 		}
-		refreshCompletions();
-		return catalog.length;
+		return count;
+	};
+	/**
+	* Install one whole snapshot on the surface in ONE synchronous commit:
+	* replace the direct skill wrappers, save the scoped overrides, and merge
+	* the completions (fresh global view + saved overrides). No await between
+	* the pieces, so a first input can never observe a half-installed catalog.
+	* A FAILED skills provider keeps the current wrappers (transitions or the
+	* previous catalog): they re-validate against the current agent at
+	* execution time, so a submitted skill name can never fall through to a
+	* plain model message while the catalog is unavailable.
+	*/
+	const installSurfaceSnapshot = (snapshot) => {
+		const scopedNames = new Set(snapshot.scopedCommands.map((command) => command.name));
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		withCommandCommit(() => {
+			if (!skillsFailed) replaceSkillCommands(snapshot.skills, scopedNames);
+			savedScopedCommands = snapshot.scopedCommands;
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
 	};
-	detach("skill catalog refresh", () => registerSkillCommands());
+	/**
+	* The revalidating transition (target/owner change): scoped previews clear
+	* so new inputs complete against the current global view only, and every
+	* old skill wrapper becomes a revalidating transition command whose
+	* handler re-fetches from the CURRENT live agent and re-checks the policy
+	* at execution time. The names survive so an already-submitted skill
+	* command can never become a plain model message mid-switch.
+	*/
+	const enterCatalogTransition = () => {
+		const names = [...skillDisposers.keys()];
+		withCommandCommit(() => {
+			for (const dispose of skillDisposers.values()) dispose();
+			skillDisposers.clear();
+			savedScopedCommands = [];
+			for (const name of names) try {
+				const dispose = commands.register({
+					name,
+					description: `[skill: revalidating] ${name}`,
+					handler: async () => {
+						const agent = await requireAgent();
+						return loadSkill(agent, name);
+					}
+				});
+				skillDisposers.set(name, dispose);
+			} catch {}
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
+	};
+	/** Whether one command name is advertised by the CURRENT completion list
+	* (the claim captured at submit time, before any session creation). */
+	const wasAdvertised = (name) => claims.has(name);
 	commands.register({
 		name: "skill",
 		description: "Load a skill into the session context",
 		input: { hint: "<name>" },
 		handler: async (invocation) => {
 			const liveAgent = await requireAgent();
-			const skills = skillService(liveAgent);
-			if (skills === void 0) return {
+			const target = skillTarget(liveAgent);
+			if (target === void 0) return {
 				kind: "error",
 				text: "skill service unavailable"
 			};
 			const name = invocation.rawInput.trim();
 			if (name !== "") return loadSkill(liveAgent, name);
-			const catalog = await skills.list({
-				cwd: sessionCwd(liveAgent),
-				scope: liveAgent
+			const catalog = await readHumanSkillCatalog(target.registry, {
+				cwd: target.cwd,
+				scope: target.scope
 			});
-			if (catalog.length === 0) return {
+			if (catalog.skills.length === 0) return {
 				kind: "error",
 				text: "no skills available"
 			};
-			app.openSettings(catalog.map((skill) => ({
+			app.openSettings(catalog.skills.map((skill) => ({
 				id: skill.name,
 				label: skill.name,
 				description: skill.description,
@@ -16737,12 +17318,38 @@ function registerTuiCommands(runner) {
 	});
 	commands.register({
 		name: "reload",
-		description: "Reload TUI settings and refresh skill commands",
+		description: "Reload TUI settings and refresh the live command/skill catalog",
 		handler: async () => {
-			let skillCount = 0;
-			try {
-				skillCount = await registerSkillCommands();
-			} catch {}
+			let catalogText = "";
+			const liveAgent = runner.liveAgent;
+			if (liveAgent !== void 0) {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: liveAgent
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.commands.length} commands \u00b7 ${outcome.snapshot.skills.length} skills`;
+					if (outcome.snapshot.issues.length > 0) catalogText += ` \u00b7 partial: ${outcome.snapshot.issues.map((issue) => issue.provider).join(", ")} unavailable`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			} else {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "preset",
+						presetId: runner.effectivePresetId
+					}
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.skills.length} human skills`;
+					if (outcome.notice !== void 0) catalogText += ` \u00b7 ${outcome.notice}`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			}
 			const settings = runner.tuiSettings;
 			if (settings !== void 0) {
 				const doc = settings.get();
@@ -16761,7 +17368,7 @@ function registerTuiCommands(runner) {
 				app.setFooterPreset(doc.footer === "compact" ? "compact" : "full");
 				app.setFullscreen(doc.fullscreen === "on");
 			}
-			app.notify(`reloaded — ${skillCount} skills \u00b7 settings reapplied`, "info");
+			app.notify(`reloaded — ${catalogText} \u00b7 settings reapplied`, "info");
 			return { kind: "success" };
 		}
 	});
@@ -17012,11 +17619,28 @@ function registerTuiCommands(runner) {
 					kind: "success",
 					text: `default preset: ${settings.get(ns)?.default ?? presets.defaultId}`
 				};
-				await settings.mutate(ns, [{
-					op: "set",
-					path: ["default"],
-					value: rest
-				}]);
+				try {
+					await settings.mutate(ns, [{
+						op: "set",
+						path: ["default"],
+						value: rest
+					}]);
+				} catch (error) {
+					return {
+						kind: "error",
+						text: safeErrorMessage(error)
+					};
+				}
+				if (runner.effectivePresetId === void 0) {
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: rest
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+				}
 				return {
 					kind: "success",
 					text: `default preset set: ${rest}`
@@ -17026,6 +17650,14 @@ function registerTuiCommands(runner) {
 				if (liveAgent === void 0) {
 					const resolved = await presets.resolve(id);
 					runner.pendingPreset = resolved.id;
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: resolved.id
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
 					return {
 						kind: "pending",
 						preset: resolved.id
@@ -17036,7 +17668,14 @@ function registerTuiCommands(runner) {
 					kind: "locked",
 					sessionId: liveAgent.session.id
 				};
-				refreshCompletions();
+				await runner.refreshCatalog({
+					source: "preset",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: runner.liveAgent
+				});
 				runner.updateWelcomeCard();
 				return {
 					kind: "switched",
@@ -17109,7 +17748,11 @@ function registerTuiCommands(runner) {
 				};
 			}), (id) => {
 				close();
-				detach("preset pick", () => pickPreset(id));
+				runOwned("preset pick", () => pickPreset(id), {
+					diag: runner.diag,
+					sessionId: () => runner.liveAgent?.session.id,
+					onError: (error) => app.notify(`preset selection failed: ${safeErrorMessage(error)}`, "error")
+				});
 			}, () => {});
 			return { kind: "success" };
 		}
@@ -17551,8 +18194,28 @@ function registerTuiCommands(runner) {
 			return { kind: "success" };
 		}
 	});
-	refreshCompletions();
-	return { refreshSkills: () => registerSkillCommands() };
+	if (initial?.snapshot !== void 0) installSurfaceSnapshot(initial.snapshot);
+	else if (initial?.skills !== void 0) withCommandCommit(() => {
+		replaceSkillCommands(initial.skills.skills, /* @__PURE__ */ new Set());
+		savedScopedCommands = [];
+		installCompletions(mergeGlobalAndSavedScoped());
+	});
+	else refreshCompletions();
+	ctx.on("commands/change", () => {
+		if (commandCommitDepth > 0) {
+			commandCommitDirty = true;
+			return;
+		}
+		refreshCompletions();
+	});
+	return {
+		/** The claim test for the dispatch: is /name advertised right now? */
+		wasAdvertised,
+		/** One synchronous catalog commit (the coordinator's install hook). */
+		installSnapshot: (snapshot) => installSurfaceSnapshot(snapshot),
+		/** The revalidating transition (the coordinator's target-change hook). */
+		enterTransition: () => enterCatalogTransition()
+	};
 }
 //#endregion
 //#region src/diag.ts
@@ -18509,6 +19172,191 @@ function parseShellWords(line) {
 	return words;
 }
 //#endregion
+//#region src/skill-catalog-refresh.ts
+/** Whether two targets are the same owner (no transition needed). The
+* preset identity is the caller-provided presetId compared EXACTLY —
+* `undefined` (the deployment default) never conflates with a user preset
+* literally named `'default'`, and a resolved id never conflates with the
+* raw id it came from (the worst case is a benign extra transition). */
+function sameTarget(left, right) {
+	if (left === void 0) return false;
+	if (left.kind !== right.kind) return false;
+	return left.kind === "agent" ? left.key === right.key : left.presetId === right.presetId;
+}
+/**
+* The coordinator. One instance per runner; `dispose()` aborts the active
+* refresh on teardown.
+*/
+var CatalogRefreshCoordinator = class {
+	epoch = 0;
+	active;
+	appliedTarget;
+	snapshot;
+	hooks;
+	lifecycleSignal;
+	diag;
+	constructor(hooks, lifecycleSignal, diag) {
+		this.hooks = hooks;
+		this.lifecycleSignal = lifecycleSignal;
+		this.diag = diag;
+	}
+	/** The last applied snapshot (for same-target partial merges and the
+	* `/reload` report). */
+	get currentSnapshot() {
+		return this.snapshot;
+	}
+	/**
+	* Run one refresh request. A new request aborts the active one; only the
+	* LATEST epoch may commit. Returns the settled outcome; never rejects
+	* (failures and supersessions are outcomes, not exceptions).
+	*/
+	async refresh(request) {
+		this.active?.controller.abort();
+		const epoch = ++this.epoch;
+		const controller = new AbortController();
+		const signal = AbortSignal.any([this.lifecycleSignal, controller.signal]);
+		this.active = {
+			epoch,
+			controller
+		};
+		const targetChanged = !sameTarget(this.appliedTarget, request.target);
+		try {
+			if (targetChanged) this.hooks.enterCatalogTransition();
+			const committed = request.target.kind === "agent" ? { snapshot: await this.hooks.readAgent(request.agent, signal) } : await this.readStandingSnapshot(request.target.presetId, signal);
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const merged = targetChanged ? committed.snapshot : this.mergePartial(committed.snapshot);
+			this.hooks.installSnapshot(merged);
+			this.snapshot = merged;
+			this.appliedTarget = request.target;
+			this.diag.info("catalog applied", {
+				epoch,
+				source: request.source,
+				commands: merged.commands.length,
+				scopedCommands: merged.scopedCommands.length,
+				skills: merged.skills.length,
+				issues: merged.issues.length
+			});
+			return {
+				kind: "applied",
+				snapshot: merged,
+				...committed.notice === void 0 ? {} : { notice: committed.notice }
+			};
+		} catch (error) {
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const message = safeErrorMessage(error);
+			this.diag.warn("catalog unavailable", {
+				epoch,
+				source: request.source,
+				error: message
+			});
+			return {
+				kind: "failed",
+				error: message
+			};
+		} finally {
+			if (this.active?.epoch === epoch) this.active = void 0;
+		}
+	}
+	/** Abort the active refresh (app teardown). Late results are dropped. */
+	dispose() {
+		this.active?.controller.abort();
+	}
+	/** Same-target partial failure: a provider issue keeps the OLD field for
+	* that provider (the old snapshot is still more useful than a blank
+	* catalog); the successful providers update as usual. */
+	mergePartial(snapshot) {
+		const old = this.snapshot;
+		if (old === void 0) return snapshot;
+		const commandsFailed = snapshot.issues.some((issue) => issue.provider === "commands");
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		if (!commandsFailed && !skillsFailed) return snapshot;
+		return Object.freeze({
+			commands: commandsFailed ? old.commands : snapshot.commands,
+			scopedCommands: commandsFailed ? old.scopedCommands : snapshot.scopedCommands,
+			skills: skillsFailed ? old.skills : snapshot.skills,
+			issues: snapshot.issues
+		});
+	}
+	/** One standing read wrapped into a skills-only surface snapshot: the
+	* sessionless view has no agent-scoped commands, and the global commands
+	* layer is already registered — only the skill wrappers are installed.
+	* An INCOMPLETE observation (`complete !== true`) is never an
+	* authoritative blank catalog: it carries a detached skills issue, so a
+	* same-target reload keeps the last-good skills (mergePartial) and a
+	* target change keeps the revalidating transition wrappers
+	* (installSurfaceSnapshot's skillsFailed guard). */
+	async readStandingSnapshot(presetId, signal) {
+		const read = await this.hooks.readStanding(presetId, signal);
+		const incomplete = read.catalog.complete !== true;
+		return {
+			snapshot: Object.freeze({
+				commands: Object.freeze([]),
+				scopedCommands: Object.freeze([]),
+				skills: read.catalog.skills,
+				issues: Object.freeze(incomplete ? [Object.freeze({
+					provider: "skills",
+					message: "incomplete skill observation"
+				})] : [])
+			}),
+			...read.notice === void 0 ? {} : { notice: read.notice }
+		};
+	}
+};
+/**
+* The deterministic, timer-free coalescer for invalidation notifications
+* (`skills/change`): while one refresh is in flight, further notifications
+* mark the gate DIRTY; when the in-flight refresh settles, ONE more refresh
+* runs if the gate is dirty. A burst therefore costs at most two reads, and
+* the re-run always observes the CURRENT ownership because the runner's
+* `start` callback reads live state at run time.
+*/
+var CoalescingRefreshGate = class {
+	inFlight = false;
+	dirty = false;
+	start;
+	/** @param start - invoked synchronously to START one owned refresh. Must
+	* never throw and must not itself be re-entrant (the gate owns the
+	* in-flight bookkeeping; `start` only launches the owned task). */
+	constructor(start) {
+		this.start = start;
+	}
+	/** One invalidation notification arrived. */
+	notify() {
+		if (this.inFlight) {
+			this.dirty = true;
+			return;
+		}
+		this.inFlight = true;
+		this.start();
+	}
+	/** Terminal settle of the in-flight refresh (called from EVERY terminal
+	* runOwned callback: onResult / onCancel / onError). Clears the in-flight
+	* flag; a dirty gate starts exactly one follow-up refresh. IDEMPOTENT: a
+	* second settle (e.g. onResult throws and runOwned routes to onError)
+	* must not clear the in-flight flag of a follow-up refresh it did not
+	* start. */
+	settled() {
+		if (!this.inFlight) return;
+		this.inFlight = false;
+		if (this.dirty) {
+			this.dirty = false;
+			this.notify();
+		}
+	}
+};
+//#endregion
 //#region src/index.ts
 /**
 * @xmoon76/dsh-pi-tui — the bundle's runner plugin. Waits for the startup
@@ -18615,11 +19463,65 @@ function shouldSteerOnEnter(parsed, running, busyEnter, forceQueue) {
 	return running && busyEnter === "steer";
 }
 /**
-* Read an explicit child-session reference from a future/extended job record.
-* Current dsh JobSnapshot records do not expose one, so this normally returns
-* undefined. Crucially, label, registration order and timestamps are never
-* accepted as identity signals.
+* The advertised-claim miss decision (pure, exported for the headless
+* suite): a slash input whose name was advertised by the completion list at
+* submit time but that the REAL session's catalog lacks is CONSUMED with an
+* explicit error — never sent to the model as a plain user message. An
+* unadvertised miss keeps the existing plain-input fallback (the user may
+* deliberately send slash text to the model).
+* @param execution - the settled `commands.execute` outcome.
+* @param wasAdvertised - the claim captured BEFORE session creation.
+* @returns whether the miss must be consumed as an advertised miss.
 */
+function shouldConsumeAdvertisedMiss(execution, wasAdvertised) {
+	return execution === void 0 && wasAdvertised;
+}
+async function resolveInitialCatalog(options) {
+	const { liveAgent, presetId, signal, ctx, diag } = options;
+	if (liveAgent !== void 0) try {
+		const snapshot = await readSurfaceCatalog(liveAgent, signal, ctx);
+		diag.info("surface catalog prefetched", {
+			commands: snapshot.commands.length,
+			scopedCommands: snapshot.scopedCommands.length,
+			skills: snapshot.skills.length
+		});
+		return { snapshot };
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("surface catalog unavailable", {
+			phase: "resume",
+			error: message
+		});
+		return { notice: `surface catalog unavailable: ${message}` };
+	}
+	const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+	if (target.target === void 0) return {};
+	try {
+		const catalog = await readHumanSkillCatalog(target.target.registry, {
+			cwd: target.target.cwd,
+			scope: target.target.scope,
+			signal
+		});
+		diag.info("skill catalog standing ready", {
+			preset: presetId ?? "default",
+			skills: catalog.skills.length,
+			complete: catalog.complete
+		});
+		return {
+			skills: catalog,
+			...target.degraded === void 0 ? {} : { notice: target.degraded }
+		};
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("skill catalog unavailable", {
+			phase: "cold",
+			error: message
+		});
+		return { notice: `skill catalog unavailable: ${message}` };
+	}
+}
 function subagentJobTranscriptId(snapshot) {
 	if (typeof snapshot !== "object" || snapshot === null) return void 0;
 	const childSessionId = snapshot.childSessionId;
@@ -19007,6 +19909,29 @@ function apply(ctx, config) {
 		let liveHandle = handle;
 		let liveAgent = handle?.agent;
 		if (liveAgent !== void 0) await liveAgent.whenIdle();
+		let initialSnapshot;
+		let initialSkills;
+		let surfaceNotice;
+		{
+			let effectivePresetId;
+			try {
+				const launched = await launchComposition();
+				if (launched.failure !== void 0) resumeFailure = launched.failure;
+				effectivePresetId = launched.composition.agentPreset;
+			} catch (error) {
+				diag.warn("preset resolution failed at startup", { error: safeErrorMessage(error) });
+			}
+			const resolution = await resolveInitialCatalog({
+				liveAgent,
+				presetId: effectivePresetId,
+				signal: lifecycleController.signal,
+				ctx,
+				diag
+			});
+			initialSnapshot = resolution.snapshot;
+			initialSkills = resolution.skills;
+			surfaceNotice = resolution.notice;
+		}
 		let guardState = freshGuardState();
 		let guardToken;
 		/**
@@ -19143,6 +20068,7 @@ function apply(ctx, config) {
 			guardToken = void 0;
 			bumpSessionGeneration();
 			await initLiveSession(next.agent);
+			await refreshLiveCatalog(next.agent);
 			diag.info("switch ok", {
 				from: from ?? "(none)",
 				to: next.agent.session.id,
@@ -19229,6 +20155,7 @@ function apply(ctx, config) {
 			cleanedUp = true;
 			guardToken = void 0;
 			lifecycleController.abort();
+			catalogCoordinator?.dispose();
 			localShellController?.abort();
 			for (const file of shellTempFiles) try {
 				rmSync(file, { force: true });
@@ -19528,6 +20455,8 @@ function apply(ctx, config) {
 		* user input is the deferred trigger), guard against cross-process
 		* divergence, then execute a registered slash command or follow up. */
 		const dispatchViaSession = (text) => {
+			const parsedAtSubmit = parseCommand(text);
+			const wasAdvertised = parsedAtSubmit !== void 0 && wasAdvertisedClaim?.(parsedAtSubmit.name) === true;
 			runOwned("submit", () => ensureSession().then(async () => {
 				const agent = liveAgent;
 				if (agent === void 0) return;
@@ -19557,6 +20486,10 @@ function apply(ctx, config) {
 						diag,
 						sessionId: () => agent.session.id,
 						onResult: (execution) => {
+							if (shouldConsumeAdvertisedMiss(execution, wasAdvertised)) {
+								app.notify(`/${parsedAtSubmit?.name ?? "?"} is not available in the created session`, "error");
+								return;
+							}
 							if (execution === void 0) {
 								if (sessionUnchanged({
 									agent,
@@ -20063,7 +20996,12 @@ function apply(ctx, config) {
 			app.setQueueItems(queue);
 		};
 		refreshQueue();
-		/** Rebuild every live-session surface after resume, create, or swap. */
+		/**
+		* Rebuild every live-session surface after resume, create, or swap.
+		* The surface catalog is NOT touched here: the initial owner's catalog
+		* came from the pre-mount prefetch/probe, and the first deferred create
+		* plus every switch await the coordinator refresh themselves.
+		*/
 		const initLiveSession = async (agent) => {
 			folder = new TranscriptFolder();
 			folder.apply(agent.session.events);
@@ -20082,8 +21020,10 @@ function apply(ctx, config) {
 			app.resetInputHistory(tuiSettings?.get().history[sessionCwd()] ?? []);
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())} · ${agent.session.id}`);
 			updateWelcomeCard();
-			registerCommands();
-			refreshSkillCommands();
+			registerCommands({
+				snapshot: initialSnapshot,
+				skills: initialSkills
+			});
 		};
 		/**
 		* Create the first session lazily — the FIRST user message triggers it
@@ -20112,6 +21052,7 @@ function apply(ctx, config) {
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				} catch (error) {
 					const message = safeErrorMessage(error);
 					ctx.logger.warn(`tui-runner: failed to start with preset "${launchPreset ?? "default"}": ${message}`);
@@ -20135,6 +21076,7 @@ function apply(ctx, config) {
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				}
 				if (resumeFailure !== void 0) {
 					app.notify(resumeFailure, "error");
@@ -20146,7 +21088,67 @@ function apply(ctx, config) {
 			return creating;
 		};
 		let commandsRegistered = false;
-		let refreshSkills;
+		/** The claim test installed by registerTuiCommands: is a slash name
+		* advertised by the CURRENT completion list? The dispatch captures it
+		* BEFORE any session creation (see dispatchViaSession). */
+		let wasAdvertisedClaim;
+		/** The catalog refresh coordinator: the ONE post-mount refresh owner
+		* (first session, switches, /preset, /reload). Built inside
+		* registerCommands once the surface hooks exist. */
+		let catalogRefreshRequest;
+		let catalogCoordinator;
+		/** `skills/change` coalescing: bursts of invalidation notifications cost
+		* at most two reads, and the follow-up re-read observes the CURRENT
+		* ownership (live agent vs standing preset). */
+		let skillsChangeSubscribed = false;
+		const skillsChangeGate = new CoalescingRefreshGate(() => {
+			runOwned("skills/change refresh", async () => {
+				const refresh = catalogRefreshRequest;
+				if (refresh === void 0) return void 0;
+				const target = liveAgent === void 0 ? {
+					kind: "preset",
+					presetId: pendingPreset ?? launchPreset
+				} : {
+					kind: "agent",
+					key: sessionGeneration
+				};
+				return refresh({
+					source: "invalidation",
+					target,
+					...target.kind === "agent" ? { agent: liveAgent } : {}
+				});
+			}, {
+				diag,
+				sessionId: () => liveAgent?.session.id,
+				onResult: (outcome) => {
+					if (outcome !== void 0 && outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+					skillsChangeGate.settled();
+				},
+				onCancel: () => {
+					skillsChangeGate.settled();
+				},
+				onError: (error) => {
+					skillsChangeGate.settled();
+					app.notify(`skill catalog refresh failed: ${safeErrorMessage(error)}`, "error");
+				}
+			});
+		});
+		/** Subscribe to the dsh-skill invalidation notification once, through
+		* the single-point adapter (plan appendix B.1). The event carries no
+		* scope or cwd, so the refresh target follows the CURRENT ownership; an
+		* unavailable or throwing subscription degrades to no subscription —
+		* owner switches and /reload still refresh. The flag is set only after
+		* a successful subscribe, so a throwing subscribe can retry on a later
+		* registration attempt. */
+		const subscribeSkillsChangeEvents = () => {
+			if (skillsChangeSubscribed) return;
+			try {
+				subscribeSkillsChange(ctx, () => skillsChangeGate.notify());
+				skillsChangeSubscribed = true;
+			} catch (error) {
+				diag.warn("skills/change subscription unavailable", { error: safeErrorMessage(error) });
+			}
+		};
 		const runner = {
 			ctx,
 			app,
@@ -20180,6 +21182,20 @@ function apply(ctx, config) {
 			set pendingPreset(id) {
 				pendingPreset = id;
 			},
+			/** The effective preset id for COLD (sessionless) reads: the run-local
+			* pending override ahead of the launch-time --preset (the SAME
+			* precedence ensureSession uses); undefined = the saved/default
+			* preset applies. */
+			get effectivePresetId() {
+				return pendingPreset ?? launchPreset;
+			},
+			refreshCatalog: (request) => {
+				const refresh = catalogRefreshRequest;
+				return refresh === void 0 ? Promise.resolve({
+					kind: "failed",
+					error: "catalog refresh unavailable"
+				}) : refresh(request);
+			},
 			switchSession,
 			swapTo: (next) => swapTo(next),
 			currentPreset,
@@ -20191,12 +21207,32 @@ function apply(ctx, config) {
 			requestExit,
 			exit
 		};
-		const registerCommands = () => {
+		const registerCommands = (initial) => {
 			if (commandsRegistered) return;
 			if (ctx.get("commands") === void 0) return;
 			commandsRegistered = true;
 			try {
-				refreshSkills = registerTuiCommands(runner).refreshSkills;
+				const installed = registerTuiCommands(runner, initial);
+				wasAdvertisedClaim = installed.wasAdvertised;
+				catalogCoordinator = new CatalogRefreshCoordinator({
+					readAgent: (agent, readSignal) => readSurfaceCatalog(agent, readSignal, ctx),
+					readStanding: async (presetId, readSignal) => {
+						const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+						if (target.target === void 0) throw new Error("skill service unavailable");
+						return {
+							catalog: await readHumanSkillCatalog(target.target.registry, {
+								cwd: target.target.cwd,
+								scope: target.target.scope,
+								signal: readSignal
+							}),
+							...target.degraded === void 0 ? {} : { notice: target.degraded }
+						};
+					},
+					installSnapshot: (next) => installed.installSnapshot(next),
+					enterCatalogTransition: () => installed.enterTransition()
+				}, lifecycleController.signal, diag);
+				catalogRefreshRequest = (request) => catalogCoordinator.refresh(request);
+				subscribeSkillsChangeEvents();
 			} catch (error) {
 				commandsRegistered = false;
 				const message = safeErrorMessage(error);
@@ -20205,13 +21241,21 @@ function apply(ctx, config) {
 				app.notify(`command registration failed: ${message}`, "error");
 			}
 		};
-		/** Rebuild the agent-scoped per-skill commands after a session exists. */
-		const refreshSkillCommands = () => {
-			const refresh = refreshSkills;
+		/** Await one live-owner catalog refresh through the coordinator (the
+		* first deferred create and every session switch): the refresh attempt
+		* settles before the caller continues, and its outcome is an outcome —
+		* provider issues degrade fields, failures warn, the submission or the
+		* switch proceeds either way. */
+		const refreshLiveCatalog = async (agent) => {
+			const refresh = catalogRefreshRequest;
 			if (refresh === void 0) return;
-			runDetached("skill command refresh", () => refresh(), {
-				diag,
-				sessionId: () => liveAgent?.session.id
+			await refresh({
+				source: "live-session",
+				target: {
+					kind: "agent",
+					key: sessionGeneration
+				},
+				agent
 			});
 		};
 		if (liveAgent !== void 0) await initLiveSession(liveAgent);
@@ -20220,7 +21264,14 @@ function apply(ctx, config) {
 			refreshStatus();
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())}`);
 		}
-		registerCommands();
+		registerCommands({
+			snapshot: initialSnapshot,
+			skills: initialSkills
+		});
+		if (surfaceNotice !== void 0) {
+			app.notify(surfaceNotice, "error");
+			surfaceNotice = void 0;
+		}
 		if (resumeFailure !== void 0) {
 			app.notify(resumeFailure, "error");
 			resumeFailure = void 0;
@@ -20330,4 +21381,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resumeCommand, runningProfile, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };
+export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };