@burdenoff/fe-libs 2026.915.4 → 2026.917.1

package/dist/shared/assistant/legacyFiller.js

@@ -1,4 +1,4 @@
-import { incompleteTurnNotice as e } from "./streamBudget.js";
+import { INCOMPLETE_TURN_NOTICES as e } from "./streamBudget.js";
 import { STAGE_COPY as t, THINKING_PHRASES as n, stageText as r } from "./stageCopy.js";
 //#region src/shared/assistant/legacyFiller.ts
 var i = [
@@ -26,7 +26,7 @@ function l(n, r) {
 	let o = r.slice(0, i).trim();
 	if (!a(n, t.thinking, o)) return null;
 	let s = r.slice(i + 2);
-	return [e("assistant"), e("vibe-plugins")].some((e) => {
+	return e.some((e) => {
 		let t = n(e.key, e.fallback);
 		return s.startsWith(e.fallback) || t !== "" && s.startsWith(t);
 	}) ? s : null;

package/dist/shared/assistant/modeCapabilities.d.ts

@@ -0,0 +1,126 @@
+import { AssistantModeConfig } from './conversation';
+import { AssistantMode, BuiltInAssistantMode } from './types';
+/**
+ * What a mode DOES, as far as the panel is concerned: whether its turns produce
+ * files, how long one turn may run, and whether an unfinished turn keeps going
+ * server-side.
+ *
+ * ★★ Capabilities, not mode ids. Each of these was a `mode === "vibe-plugins"`
+ * test scattered across the panel, which meant no other mode could ever list
+ * artifacts or run a long build — however it was configured — without another
+ * edit to shared code naming it. A product now says what its mode does on its
+ * `AssistantModeConfig`, and this is the one place that decides.
+ *
+ * ★ Built-in ids keep their built-in behaviour when the product says nothing.
+ * That is what keeps an existing product byte-identical: VibeControls' `Build`
+ * mode is `vibe-plugins` with none of these fields, and resolves exactly as the
+ * hard-coded checks did (artifacts, 600s, "still building").
+ */
+export interface AssistantModeCapabilities {
+    /** List `/sessions/:id/artifacts` after each turn and render them. */
+    readonly producesArtifacts: boolean;
+    /** How long the client polls one turn before closing it as unfinished. */
+    readonly streamBudgetMs: number;
+    /** An unfinished turn keeps building server-side — selects the "still building" note. */
+    readonly continuesInBackground: boolean;
+    /**
+     * Report this run's narration for the WHOLE run, joined oldest first, instead
+     * of only its newest message (BC1, BOFF-7334).
+     *
+     * ★★ Off for every mode by default, and deliberately so. Latest-only is what
+     * both host panels and every product wrapping the shared transport render
+     * today, so this cannot be switched on globally. It also changes what is
+     * STORED — the completed turn persists this content as its answer — so only a
+     * mode whose answer IS the account of what it built should ask for it.
+     */
+    readonly accumulatesNarration: boolean;
+    /**
+     * May the panel provision a sandbox for this mode at all.
+     *
+     * ★ `false` only for a mode that is neither built in nor declared by the
+     * product — a persisted id from another build, or a malformed one. It fails
+     * CLOSED: no sandbox, no artifacts, the default budget.
+     */
+    readonly provisionable: boolean;
+}
+/** The capability fields a product may set, plus the id they belong to. */
+export type AssistantModeCapabilityConfig = Pick<AssistantModeConfig, "id" | "producesArtifacts" | "streamBudgetMs" | "continuesInBackground" | "accumulatesNarration">;
+/**
+ * The largest `streamBudgetMs` a product may configure: one hour.
+ *
+ * The sandbox TTL is extended every 30s while a turn is polled, so a long budget
+ * never outlives the sandbox — but a value like `Infinity` or a seconds/ms mix-up
+ * (`600_000_000`) would leave a spinner up for days. Out-of-range values fall
+ * back to the default rather than throwing, for the same reason a `NaN` must.
+ */
+export declare const MAX_ASSISTANT_STREAM_BUDGET_MS = 3600000;
+/**
+ * The built-in modes' behaviour. The ONLY table in shared code that knows
+ * `vibe-plugins` builds things.
+ */
+export declare const BUILT_IN_MODE_CAPABILITIES: Readonly<Record<BuiltInAssistantMode, AssistantModeCapabilities>>;
+/** Fail-closed result for a mode nobody declared. */
+export declare const UNDECLARED_MODE_CAPABILITIES: AssistantModeCapabilities;
+/**
+ * The capabilities of `mode`, given the product's config for it.
+ *
+ * - Built-in id: its built-in behaviour, with any field the product set applied
+ *   over it.
+ * - Product-declared id WITH a config: chat defaults with the product's fields
+ *   applied. Declared means "the product offers a config for exactly this id".
+ * - Anything else — an unoffered product id, a malformed id, no mode at all:
+ *   `UNDECLARED_MODE_CAPABILITIES`.
+ *
+ * ★ A config whose `id` is not `mode` is IGNORED. The caller looked it up, and a
+ * lookup that fell back to another mode (as `resolveModeConfig` does, by design,
+ * for display) would otherwise lend one mode's 10-minute budget and artifact
+ * listing to another.
+ *
+ * ★ `continuesInBackground` follows `producesArtifacts` when only the latter is
+ * set: the "still building" note promises "any artifacts below will finish
+ * shortly", which is only ever true of a mode that produces them.
+ */
+export declare function resolveAssistantModeCapabilities(mode: AssistantMode | null | undefined, config?: AssistantModeCapabilityConfig | null): AssistantModeCapabilities;
+/**
+ * Why a send in an admin-only mode must not go out yet, or null when it may.
+ *
+ * ★★ The mode list hides an admin-only mode from a non-admin, and an effect
+ * resets a persisted one back to Ask — but only AFTER the role check resolves,
+ * so an admin's own persisted choice is not reset during that window. A send in
+ * the window used to go straight through: the mode was provisioned while the
+ * answer was still unknown, and the proxy-token modes have no server-side admin
+ * check behind it. So the send asks the same question the list does.
+ *
+ * ★★ `loading` is NOT the send's normal path through here. The send WAITS for
+ * the check (`adminOnlyModeSendRefusalAfterAccess`), because refusing during it
+ * broke every product whose help button opens the panel and sends on the next
+ * tick. Reaching this branch means that wait timed out, so the copy says the
+ * check has not finished — it must never read as a refusal of the person.
+ *
+ * Only a config that says `requiresAdmin` is gated — Ask carries no such flag
+ * and is never held. Truthiness is read exactly as the mode list and the reset
+ * effect read it, so for any config the three agree.
+ *
+ * ★ The one case where they do not is a mode with NO config at all: the reset
+ * effect treats a missing config as blocked, while `requiresAdmin` is simply
+ * absent here, so nothing is gated. That is reachable only for a built-in id a
+ * build has stopped declaring — where there is no admin check to consult
+ * anyway, and `createApp` is RBAC-gated server-side regardless.
+ */
+export declare function adminOnlyModeSendRefusal(config: {
+    readonly requiresAdmin?: boolean;
+} | null | undefined, access: {
+    readonly loading: boolean;
+    readonly canUseAdminModes: boolean;
+}): string | null;
+/**
+ * The product's config for EXACTLY this mode, or undefined.
+ *
+ * ★ Deliberately not `resolveModeConfig` (product.tsx), which falls back to the
+ * first mode so a stale id still renders suggestions. Behaviour must never be
+ * borrowed that way — see `resolveAssistantModeCapabilities`.
+ */
+export declare function findAssistantModeConfig<T extends {
+    id: AssistantMode;
+}>(modes: readonly T[] | null | undefined, mode: AssistantMode | null | undefined): T | undefined;
+//# sourceMappingURL=modeCapabilities.d.ts.map

package/dist/shared/assistant/modeCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeCapabilities.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/modeCapabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,yBAAyB;IACxC,sEAAsE;IACtE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,0EAA0E;IAC1E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yFAAyF;IACzF,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC;;;;;;;;;OASG;IACH,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED,2EAA2E;AAC3E,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,mBAAmB,EACjB,IAAI,GACJ,mBAAmB,GACnB,gBAAgB,GAChB,uBAAuB,GACvB,sBAAsB,CACzB,CAAC;AAKF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,UAAY,CAAC;AAUxD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAC/C,MAAM,CAAC,oBAAoB,EAAE,yBAAyB,CAAC,CAkBvD,CAAC;AAEH,qDAAqD;AACrD,eAAO,MAAM,4BAA4B,EAAE,yBAOvC,CAAC;AAeL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,CAAC,EAAE,6BAA6B,GAAG,IAAI,GAC5C,yBAAyB,CAyB3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAC/D,MAAM,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAA;CAAE,GACxE,MAAM,GAAG,IAAI,CASf;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,aAAa,CAAA;CAAE,EACrE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GACrC,CAAC,GAAG,SAAS,CAGf"}

package/dist/shared/assistant/modeCapabilities.js

@@ -0,0 +1,50 @@
+import { isBuiltInAssistantMode as e } from "./modeCopy.js";
+import { isProductAssistantModeId as t } from "./modeIds.js";
+//#region src/shared/assistant/modeCapabilities.ts
+var n = 18e4, r = 6e5, i = 36e5, a = Object.freeze({
+	producesArtifacts: !1,
+	streamBudgetMs: n,
+	continuesInBackground: !1,
+	accumulatesNarration: !1,
+	provisionable: !0
+}), o = Object.freeze({
+	general: a,
+	assistant: a,
+	"api-calls": a,
+	"vibe-plugins": Object.freeze({
+		producesArtifacts: !0,
+		streamBudgetMs: r,
+		continuesInBackground: !0,
+		accumulatesNarration: !1,
+		provisionable: !0
+	})
+}), s = Object.freeze({
+	producesArtifacts: !1,
+	streamBudgetMs: n,
+	continuesInBackground: !1,
+	accumulatesNarration: !1,
+	provisionable: !1
+}), c = (e) => typeof e == "boolean" ? e : void 0, l = (e) => typeof e == "number" && Number.isFinite(e) && e > 0 && e <= 36e5 ? e : void 0;
+function u(n, r) {
+	let i = r && r.id === n ? r : void 0, u;
+	if (e(n)) u = o[n];
+	else if (i && t(n)) u = a;
+	else return s;
+	if (!i) return u;
+	let d = c(i.producesArtifacts);
+	return {
+		producesArtifacts: d ?? u.producesArtifacts,
+		streamBudgetMs: l(i.streamBudgetMs) ?? u.streamBudgetMs,
+		continuesInBackground: c(i.continuesInBackground) ?? d ?? u.continuesInBackground,
+		accumulatesNarration: c(i.accumulatesNarration) ?? u.accumulatesNarration,
+		provisionable: !0
+	};
+}
+function d(e, t) {
+	return e?.requiresAdmin ? t.loading ? "Still checking whether you can use this assistant mode. Wait a moment, then send again." : t.canUseAdminModes ? null : "This assistant mode is only available to organization admins. Switch to another mode and send again." : null;
+}
+function f(e, t) {
+	if (t) return e?.find((e) => e.id === t);
+}
+//#endregion
+export { o as BUILT_IN_MODE_CAPABILITIES, i as MAX_ASSISTANT_STREAM_BUDGET_MS, s as UNDECLARED_MODE_CAPABILITIES, d as adminOnlyModeSendRefusal, f as findAssistantModeConfig, u as resolveAssistantModeCapabilities };

package/dist/shared/assistant/modeCopy.d.ts

@@ -1,4 +1,4 @@
-import { AssistantMode } from './types';
+import { AssistantMode, BuiltInAssistantMode } from './types';
 /**
  * The shared English name of each mode: what a mode pill shows when the
  * product's own `label` is empty.
@@ -9,9 +9,10 @@ import { AssistantMode } from './types';
  * the manifest outside any React tree — so neither may live behind a component
  * import.
  *
- * ★ `satisfies Record<AssistantMode, string>` makes the table exactly the mode
- * union: a new mode without a name here, or a name for a mode that no longer
- * exists, fails the typecheck.
+ * ★ `satisfies Record<BuiltInAssistantMode, string>` makes the table exactly
+ * the built-in union: a new built-in mode without a name here, or a name for a
+ * mode that no longer exists, fails the typecheck. Product-declared modes are
+ * named by `assistantModeFallbackLabel`.
  */
 export declare const ASSISTANT_MODE_FALLBACK_LABELS: {
     readonly general: "Ask";
@@ -20,8 +21,27 @@ export declare const ASSISTANT_MODE_FALLBACK_LABELS: {
     readonly "vibe-plugins": "Build";
 };
 /**
- * Every mode id, read off the table above so the list cannot fall behind the
- * union.
+ * Every BUILT-IN mode id, read off the table above so the list cannot fall
+ * behind the union. Product-declared ids are, by design, not listed anywhere in
+ * shared code — see `ProductAssistantMode`.
  */
-export declare const ASSISTANT_MODE_IDS: readonly AssistantMode[];
+export declare const ASSISTANT_MODE_IDS: readonly BuiltInAssistantMode[];
+/**
+ * Is this one of fe-libs' own modes?
+ *
+ * ★ Lives beside the table it reads, so the check and the list are one thing.
+ * `Object.hasOwn`, not `in`: `"toString" in table` is true.
+ */
+export declare function isBuiltInAssistantMode(value: unknown): value is BuiltInAssistantMode;
+/**
+ * The shared English name for a mode whose product gave an empty `label`.
+ *
+ * Built-in: the table above. Product-declared: named by what it does — the
+ * build mode's word for a mode that `producesArtifacts`, otherwise Ask's. Same
+ * two words the built-ins already use, so no new copy exists to seed.
+ */
+export declare function assistantModeFallbackLabel(mode: {
+    id: AssistantMode;
+    producesArtifacts?: boolean;
+}): string;
 //# sourceMappingURL=modeCopy.d.ts.map

package/dist/shared/assistant/modeCopy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modeCopy.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/modeCopy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;;;;CAKO,CAAC;AAEnD;;;GAGG;AAGH,eAAO,MAAM,kBAAkB,EAE1B,SAAS,aAAa,EAAE,CAAC"}
+{"version":3,"file":"modeCopy.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/modeCopy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,8BAA8B;;;;;CAKc,CAAC;AAE1D;;;;GAIG;AAGH,eAAO,MAAM,kBAAkB,EAE1B,SAAS,oBAAoB,EAAE,CAAC;AAErC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAK/B;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,EAAE,EAAE,aAAa,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,GAAG,MAAM,CAOT"}

package/dist/shared/assistant/modeCopy.js

@@ -5,5 +5,11 @@ var e = {
 	"api-calls": "Take action",
 	"vibe-plugins": "Build"
 }, t = Object.keys(e);
+function n(t) {
+	return typeof t == "string" && Object.hasOwn(e, t);
+}
+function r(t) {
+	return n(t.id) ? e[t.id] : t.producesArtifacts === !0 ? e["vibe-plugins"] : e.assistant;
+}
 //#endregion
-export { e as ASSISTANT_MODE_FALLBACK_LABELS, t as ASSISTANT_MODE_IDS };
+export { e as ASSISTANT_MODE_FALLBACK_LABELS, t as ASSISTANT_MODE_IDS, r as assistantModeFallbackLabel, n as isBuiltInAssistantMode };

package/dist/shared/assistant/modeIds.d.ts

@@ -0,0 +1,67 @@
+import { AssistantMode, BuiltInAssistantMode, ProductAssistantMode } from './types';
+export { isBuiltInAssistantMode } from './modeCopy';
+/**
+ * Which strings may name an assistant mode.
+ *
+ * Built-in ids are the `BuiltInAssistantMode` union. Everything else is a
+ * PRODUCT-declared id (see `ProductAssistantMode`) and must pass the checks
+ * below before shared code will provision, reuse, time or label a sandbox for it.
+ */
+/**
+ * Lowercase kebab-case: `general`, `api-calls`, `vibe-plugins` all fit, and so
+ * does every product persona the sandbox service knows today.
+ *
+ * ★ Not cosmetic. The id is interpolated into the sandbox NAME
+ * (`ai-assistant-<id>-<epoch ms>`, a DNS-1123 label on the Kubernetes backend),
+ * stamped into its metadata, sent as `AI_ASSISTANT_MODE`, and becomes the last
+ * segment of the `mode.<id>` i18n key — where a `.` would split the key and a
+ * capital or space would make it unseedable.
+ */
+export declare const PRODUCT_ASSISTANT_MODE_ID_PATTERN: RegExp;
+/**
+ * `ai-assistant-` (13) + id + `-` + 13-digit epoch ms must stay within the
+ * 63-character label limit: 63 - 27 = 36, rounded down for headroom.
+ */
+export declare const PRODUCT_ASSISTANT_MODE_ID_MAX_LENGTH = 32;
+/**
+ * The built-in mode `value` extends with a `-` segment (`general-docs` →
+ * `general`), or undefined.
+ *
+ * ★★ Such an id is refused. Its sandboxes would be named
+ * `ai-assistant-general-docs-<epoch>`, which starts with the built-in's
+ * `ai-assistant-general-` — the prefix legacy built-in sandboxes are still
+ * recognised by. Metadata now decides first (`resolveSandboxAssistantMode`), so
+ * this is the second wall: no id a product can declare is a name-prefix
+ * collision with a built-in in the first place.
+ */
+export declare function builtInModeExtendedBy(value: string): BuiltInAssistantMode | undefined;
+/**
+ * A well-formed id that is NOT built in and does not extend a built-in's name —
+ * i.e. one only a product can declare.
+ */
+export declare function isProductAssistantModeId(value: unknown): value is ProductAssistantMode;
+/** Built in, or a well-formed product id. Says nothing about whether it is OFFERED. */
+export declare function isAssistantModeId(value: unknown): value is AssistantMode;
+/**
+ * Admit a backend mode id a product offers — the one way to obtain a
+ * `ProductAssistantMode`.
+ *
+ * ```ts
+ * const NODE_BUILDER = declareAssistantMode("acme-node");
+ * const modes = [{ id: NODE_BUILDER, label: "Build a node", producesArtifacts: true, streamBudgetMs: 600_000, ... }];
+ * ```
+ *
+ * ★ Throws rather than returning null: this runs once at module load in the
+ * product, where a thrown error is a failed build or a red test, not a user-facing
+ * crash — and a mode that silently failed to declare would vanish from the panel.
+ *
+ * ★ A declared mode gets NO authority. It never receives the user's tokens, never
+ * runs read-only or write-gated, and runs on the proxy-token artifact image; see
+ * `sandboxBaseModeFor` and `forwardsUserTokensToSandbox`. Authority is granted
+ * only by being `assistant` or `api-calls`, which is a fe-libs change.
+ *
+ * @throws when `id` is a built-in mode (use it directly), extends a built-in's
+ *   name (`general-docs`), or is not a valid id.
+ */
+export declare function declareAssistantMode(id: string): ProductAssistantMode;
+//# sourceMappingURL=modeIds.d.ts.map

package/dist/shared/assistant/modeIds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeIds.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/modeIds.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAIjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,iCAAiC,QAAoC,CAAC;AAEnF;;;GAGG;AACH,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GACZ,oBAAoB,GAAG,SAAS,CAElC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAQ/B;AAED,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAExE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,CAkBrE"}

package/dist/shared/assistant/modeIds.js

@@ -0,0 +1,21 @@
+import { ASSISTANT_MODE_IDS as e, isBuiltInAssistantMode as t } from "./modeCopy.js";
+//#region src/shared/assistant/modeIds.ts
+var n = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/, r = 32;
+function i(t) {
+	return e.find((e) => t.startsWith(`${e}-`));
+}
+function a(e) {
+	return typeof e == "string" && e.length <= 32 && n.test(e) && !t(e) && i(e) === void 0;
+}
+function o(e) {
+	return t(e) || a(e);
+}
+function s(e) {
+	if (t(e)) throw Error(`declareAssistantMode: ${JSON.stringify(e)} is a built-in mode; use the id directly.`);
+	let n = typeof e == "string" ? i(e) : void 0;
+	if (n !== void 0) throw Error(`declareAssistantMode: ${JSON.stringify(e)} starts with the built-in mode "${n}-"; its sandboxes would be named like that mode's. Choose an id that does not.`);
+	if (!a(e)) throw Error(`declareAssistantMode: ${JSON.stringify(e)} is not a valid mode id (lowercase kebab-case, at most 32 characters).`);
+	return e;
+}
+//#endregion
+export { r as PRODUCT_ASSISTANT_MODE_ID_MAX_LENGTH, n as PRODUCT_ASSISTANT_MODE_ID_PATTERN, i as builtInModeExtendedBy, s as declareAssistantMode, o as isAssistantModeId, a as isProductAssistantModeId };

package/dist/shared/assistant/preview/AssistantPreviewOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantPreviewOverlay.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/preview/AssistantPreviewOverlay.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAA6B,KAAK,EAAE,EAAkB,MAAM,OAAO,CAAC;AA2E3E,eAAO,MAAM,uBAAuB,EAAE,EAAE,CAAC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAwF/D,CAAC"}
+{"version":3,"file":"AssistantPreviewOverlay.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/preview/AssistantPreviewOverlay.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAA6B,KAAK,EAAE,EAAkB,MAAM,OAAO,CAAC;AA2E3E,eAAO,MAAM,uBAAuB,EAAE,EAAE,CAAC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA4F/D,CAAC"}

package/dist/shared/assistant/progress.d.ts

@@ -15,13 +15,50 @@ export declare function getAssistantText(parts: AssistantRawMessage['parts']): s
  * the source is protocol-checked. A part we cannot render safely is DROPPED.
  */
 export declare function getAssistantMedia(parts: AssistantRawMessage['parts']): string[];
+/**
+ * One line per tool part: `"<Verb>: <tool>"`, with `" · <description>"` appended
+ * when the agent said what it was doing.
+ *
+ * ★★ APPENDED, not substituted. `parseToolActivity` puts the text after the verb
+ * into `step.tool` — which is what the collapsed "Details" row renders and what
+ * `step.id` is keyed on — so replacing the tool name with the description would
+ * blank the only place the raw tool is visible, and churn the React key (and the
+ * preview rail's follow-the-run logic, which tracks steps by id) on every poll
+ * where the wording changed.
+ */
 export declare function getToolProgress(parts: AssistantRawMessage['parts']): string[];
 /**
  * Reduce the assistant messages created at/after `sinceMs` into display content +
  * a done flag. Done ⇔ the newest assistant message has `info.time.completed` and
  * carries either text or tool progress.
  */
-export declare function buildProgress(messages: AssistantRawMessage[], sinceMs: number): {
+/**
+ * Per-reduction behaviour a MODE may ask for. Every field is optional and every
+ * default reproduces today's output byte for byte — this reducer is what every
+ * product wrapping the shared transport renders through, so a behaviour change
+ * here is a behaviour change for all of them at once.
+ */
+export interface AssistantProgressOptions {
+    /**
+     * Join this run's narration across ALL of its messages, oldest first, instead
+     * of reporting only the newest one (BC1, BOFF-7334).
+     *
+     * ★★ Why it is opt-in. The agent grows text parts INSIDE one message, so
+     * content grows while it stays in message N — and the instant it opens message
+     * N+1, everything narrated in messages 1..N disappears on the next poll. A
+     * consumer that harvests entity links out of that prose loses every link
+     * printed before the current message. But latest-only is what every existing
+     * product renders today, so only a mode that asks for accumulation gets it.
+     *
+     * ★★ It changes what is STORED, not just what is shown: the orchestrator
+     * persists this content as the turn's answer, so an accumulating mode keeps a
+     * running account of the build rather than a final reply — and that is what
+     * Copy, Export and read-aloud will carry. Correct for a mode whose answer IS
+     * the build; wrong for a conversational one. Hence per mode, never global.
+     */
+    readonly accumulateNarration?: boolean;
+}
+export declare function buildProgress(messages: AssistantRawMessage[], sinceMs: number, options?: AssistantProgressOptions): {
     content: string;
     done: boolean;
 };

package/dist/shared/assistant/progress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/progress.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAA2B,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEpG,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAE3E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,CAM5E;AA8CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAkB/E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAU7E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,OAAO,EAAE,MAAM,GACd;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAuBpC;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAItE;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA0BrD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,mBAAmB,EAAE,EAClC,QAAQ,EAAE,mBAAmB,EAAE,GAC9B,mBAAmB,EAAE,CAavB;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,sBAAsB,EAAE,CAyB7F"}
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/progress.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAA2B,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEpG,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAE3E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,CAM5E;AA8CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAkB/E;AA0CD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAY7E;AAED;;;;GAIG;AACH;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,wBAAwB,GACjC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CA6BpC;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAItE;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA0BrD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,mBAAmB,EAAE,EAClC,QAAQ,EAAE,mBAAmB,EAAE,GAC9B,mBAAmB,EAAE,CAavB;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,sBAAsB,EAAE,CAyB7F"}

package/dist/shared/assistant/progress.js

@@ -33,37 +33,51 @@ function a(e) {
 	return t;
 }
 function o(e) {
+	return typeof e == "object" && e ? e : void 0;
+}
+function s(e) {
+	let t = o(e.state?.input);
+	if (!t) return;
+	let n = t.description;
+	if (typeof n == "string" && n.trim()) return n.trim();
+	let r = t.todos;
+	if (Array.isArray(r)) {
+		let e = o(r.find((e) => o(e)?.status === "in_progress") ?? r[0])?.content;
+		if (typeof e == "string" && e.trim()) return e.trim();
+	}
+}
+function c(e) {
 	return (e ?? []).filter((e) => e.type === "tool" && e.tool).map((e) => {
-		let t = e.state?.status ?? "running", n = e.tool ?? "tool";
-		return t === "completed" ? `Completed: ${n}` : t === "failed" ? `Failed: ${n}` : `Running: ${n}`;
+		let t = e.state?.status ?? "running", n = e.tool ?? "tool", r = s(e), i = r ? `${n} · ${r}` : n;
+		return t === "completed" ? `Completed: ${i}` : t === "failed" ? `Failed: ${i}` : `Running: ${i}`;
 	});
 }
-function s(n, r) {
-	let i = n.filter((t) => t.info?.role === "assistant" && e(t) >= r).sort((t, n) => e(t) - e(n));
-	if (i.length === 0) return {
+function l(n, r, i) {
+	let o = n.filter((t) => t.info?.role === "assistant" && e(t) >= r).sort((t, n) => e(t) - e(n));
+	if (o.length === 0) return {
 		content: "Thinking…",
 		done: !1
 	};
-	let s = i[i.length - 1], c = t(s.parts), l = a(s.parts), u = o(s.parts);
+	let s = o[o.length - 1], l = i?.accumulateNarration ? o.map((e) => t(e.parts)).filter(Boolean).join("\n\n") : t(s.parts), u = a(s.parts), d = c(s.parts);
 	return {
 		content: [
-			c,
-			...l,
-			...u
+			l,
+			...u,
+			...d
 		].filter(Boolean).join("\n\n") || "Thinking…",
-		done: !!s.info?.time?.completed && (!!c || l.length > 0 || u.length > 0)
+		done: !!s.info?.time?.completed && (!!l || u.length > 0 || d.length > 0)
 	};
 }
-function c(e) {
+function u(e) {
 	return e.replace(/(Authorization\s*:\s*Bearer\s+)[^\s\n]+/gi, "$1[REDACTED]").replace(/(X-Workspace-Authorization\s*:\s*Bearer\s+)[^\s\n]+/gi, "$1[REDACTED]").replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+\b/g, "[REDACTED_JWT]").replace(/\bsk-ant-[A-Za-z0-9-]+\b/g, "[REDACTED_API_KEY]");
 }
-function l(e) {
+function d(e) {
 	let t = e instanceof Error ? e.message.toLowerCase() : String(e).toLowerCase();
 	return t.includes("unable to connect") && t.includes("able to access the url");
 }
-function u(e) {
+function f(e) {
 	let t = e instanceof Error ? e.message.toLowerCase() : String(e).toLowerCase();
-	return t.includes("rate limit exceeded") || t.includes("unauthorized") || t.includes("k8s api error 401") ? !1 : l(e) ? !0 : [
+	return t.includes("rate limit exceeded") || t.includes("unauthorized") || t.includes("k8s api error 401") ? !1 : d(e) ? !0 : [
 		"sandbox not found",
 		"sandbox is not running",
 		"sandbox service not available yet",
@@ -79,7 +93,7 @@ function u(e) {
 		"proxy error: 503"
 	].some((e) => t.includes(e));
 }
-function d(t, n) {
+function p(t, n) {
 	let r = /* @__PURE__ */ new Map();
 	for (let e of t) {
 		let t = e.info?.id;
@@ -91,7 +105,7 @@ function d(t, n) {
 	}
 	return Array.from(r.values()).sort((t, n) => e(t) - e(n));
 }
-function f(n) {
+function m(n) {
 	let r = [];
 	for (let i of n) {
 		let n = i.info?.role;
@@ -106,4 +120,4 @@ function f(n) {
 	return r;
 }
 //#endregion
-export { s as buildProgress, a as getAssistantMedia, t as getAssistantText, e as getRawMessageCreatedAt, o as getToolProgress, l as isReapedSandboxConnectionError, u as isRecoverable, f as mapSessionToHistory, d as mergeMessagesById, c as sanitize };
+export { l as buildProgress, a as getAssistantMedia, t as getAssistantText, e as getRawMessageCreatedAt, c as getToolProgress, d as isReapedSandboxConnectionError, f as isRecoverable, m as mapSessionToHistory, p as mergeMessagesById, u as sanitize };

package/dist/shared/assistant/streamBudget.d.ts

@@ -1,15 +1,16 @@
-import { AssistantMode } from './types';
+import { AssistantModeCapabilityConfig } from './modeCapabilities';
+import { AssistantMode, BuiltInAssistantMode } from './types';
 /**
  * How long the client streams progress before it stops polling a turn.
  *
- * Chat replies (general / api-calls) finish in seconds; a vibe-plugins build is
- * a multi-step pipeline (read docs → scaffold → bun install → bun build →
- * checklist) that runs for minutes, so it gets a much larger budget. The sandbox
- * TTL is auto-extended every 30s during the poll loop, so a longer budget never
- * outlives the sandbox.
+ * Chat replies finish in seconds; a build is a multi-step pipeline that runs for
+ * minutes, so it gets a much larger budget. Which modes build is a CAPABILITY
+ * (`streamBudgetMs` on `AssistantModeConfig`, resolved in `modeCapabilities.ts`),
+ * not a list of mode ids. The sandbox TTL is auto-extended every 30s during the
+ * poll loop, so a longer budget never outlives the sandbox.
  *
  * ★★ THE BUDGET ELAPSING IS NOT AN ERROR. It used to be, for every mode except
- * vibe-plugins: the poll loop `throw`ew, the catch wrote
+ * the build mode: the poll loop `throw`ew, the catch wrote
  * `Sorry, an error occurred: …` into the assistant message, and that error was
  * PERSISTED — it survived a reload, so the turn was destroyed rather than
  * merely unfinished. Measured in production on 2026-09-12 with a 10.8 KB
@@ -21,29 +22,28 @@ import { AssistantMode } from './types';
  * overwrite the conversation. So the budget elapsing now yields a normal
  * assistant message: whatever content arrived, plus an honest closing note.
  */
-export declare const STREAM_BUDGET_MS: Record<AssistantMode, number>;
-export declare const DEFAULT_STREAM_BUDGET_MS = 180000;
+export declare const STREAM_BUDGET_MS: Record<BuiltInAssistantMode, number>;
+export declare const DEFAULT_STREAM_BUDGET_MS: number;
 /**
- * Budget for `mode`, falling back to the default for a mode added later.
+ * Budget for `mode`, with the product's config for it applied.
  *
  * Exported as a function rather than leaving callers to index the record, so a
  * new mode cannot silently get `undefined` and a `NaN` deadline.
  */
-export declare function streamBudgetMs(mode: AssistantMode): number;
+export declare function streamBudgetMs(mode: AssistantMode, config?: AssistantModeCapabilityConfig | null): number;
 /** i18n key + English fallback for the note closing an unfinished turn. */
 export interface IncompleteTurnNotice {
     key: string;
     fallback: string;
 }
 /**
- * ★ NO PLACEHOLDERS IN EITHER FALLBACK, deliberately.
+ * Every note that can close an unfinished turn, whatever the mode.
  *
- * `t()` did not interpolate single-brace placeholders until fe-libs 2026.910.7,
- * and 37 app shells still pin older builds, so a `{minutes}` here would render
- * raw braces to real users on most of the fleet. The elapsed budget is not worth
- * that risk, and a reader does not need the number to know what to do next.
+ * ★ Two keys for any number of modes: the copy is chosen by capability, so a
+ * product declaring a new mode adds no notice keys to seed.
  */
-export declare function incompleteTurnNotice(mode: AssistantMode): IncompleteTurnNotice;
+export declare const INCOMPLETE_TURN_NOTICES: readonly IncompleteTurnNotice[];
+export declare function incompleteTurnNotice(mode: AssistantMode, config?: AssistantModeCapabilityConfig | null): IncompleteTurnNotice;
 /**
  * Close an unfinished turn: keep every character the turn did produce, then
  * append the note for `mode`.
@@ -53,5 +53,5 @@ export declare function incompleteTurnNotice(mode: AssistantMode): IncompleteTur
  * silent failure. `translate` is injected rather than taken from a hook so this
  * is testable without a React tree or an i18n provider.
  */
-export declare function withIncompleteTurnNotice(content: string, mode: AssistantMode, translate: (key: string, fallback: string) => string): string;
+export declare function withIncompleteTurnNotice(content: string, mode: AssistantMode, translate: (key: string, fallback: string) => string, config?: AssistantModeCapabilityConfig | null): string;
 //# sourceMappingURL=streamBudget.d.ts.map

package/dist/shared/assistant/streamBudget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamBudget.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/streamBudget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAK1D,CAAC;AAEF,eAAO,MAAM,wBAAwB,SAAU,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAE1D;AAED,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,GAClB,oBAAoB,CAsBtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,GACnD,MAAM,CAWR"}
+{"version":3,"file":"streamBudget.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/streamBudget.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,6BAA6B,EACnC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAKjE,CAAC;AAEF,eAAO,MAAM,wBAAwB,QACQ,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,aAAa,EACnB,MAAM,CAAC,EAAE,6BAA6B,GAAG,IAAI,GAC5C,MAAM,CAER;AAED,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+BD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,oBAAoB,EAGlE,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,EACnB,MAAM,CAAC,EAAE,6BAA6B,GAAG,IAAI,GAC5C,oBAAoB,CAMtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,EACpD,MAAM,CAAC,EAAE,6BAA6B,GAAG,IAAI,GAC5C,MAAM,CAWR"}