@bike4mind/cli 0.15.3 → 0.17.0

package/dist/{ConfigStore-D4gALtkZ.mjs → ConfigStore-CNveAjEv.mjs}

@@ -291,9 +291,6 @@ let ImageModels = /* @__PURE__ */ function(ImageModels) {
 	ImageModels["FLUX_PRO_1_1"] = "flux-pro-1.1";
 	ImageModels["FLUX_PRO_ULTRA"] = "flux-pro-1.1-ultra";
 	ImageModels["FLUX_PRO_FILL"] = "flux-pro-1.0-fill";
-	ImageModels["FLUX_PRO_CANNY"] = "flux-pro-1.0-canny";
-	ImageModels["FLUX_PRO_DEPTH"] = "flux-pro-1.0-depth";
-	ImageModels["FLUX_DEV"] = "flux-dev";
 	ImageModels["FLUX_KONTEXT_PRO"] = "flux-kontext-pro";
 	ImageModels["FLUX_KONTEXT_MAX"] = "flux-kontext-max";
 	ImageModels["GROK_IMAGINE_IMAGE_QUALITY"] = "grok-imagine-image-quality";
@@ -593,7 +590,8 @@ const b4mLLMTools = z.enum([
 	"navigate_view",
 	"generate_jupyter_notebook",
 	"excel_generation",
-	"fmp_financial_data"
+	"fmp_financial_data",
+	"skill"
 ]);
 b4mLLMTools.options.map((tool) => tool);
 /**
@@ -905,6 +903,45 @@ const ClaudeArtifactMimeTypes = {
 	PYTHON: "application/vnd.ant.python",
 	BLOG_DRAFT: "application/vnd.b4m.blog-draft"
 };
+/**
+* Map a MIME type (or AI-provider artifact-type string) to an internal {@link ArtifactType}.
+*
+* Single source of truth — consumed by the artifact parsers (b4m-core/utils + client) and the
+* tool_result dedup in ChatCompletionProcess. Exact blessed-type matches first (case-insensitive,
+* since MIME types are), then language/format inference; returns null if unrecognized.
+*
+* #8907: this previously lived as three hand-maintained copies that drifted — e.g. the lattice
+* tool emits `application/vnd.b4m.lattice` but a copy matched `application/vnd.ant.lattice`,
+* letting lattice tool_result artifacts dodge the dedup set (#8905).
+*/
+function mapMimeTypeToArtifactType(mimeType) {
+	if (!mimeType) return null;
+	const normalized = mimeType.toLowerCase().trim();
+	switch (normalized) {
+		case ClaudeArtifactMimeTypes.REACT.toLowerCase(): return "react";
+		case ClaudeArtifactMimeTypes.HTML.toLowerCase(): return "html";
+		case ClaudeArtifactMimeTypes.SVG.toLowerCase(): return "svg";
+		case ClaudeArtifactMimeTypes.MERMAID.toLowerCase(): return "mermaid";
+		case ClaudeArtifactMimeTypes.RECHARTS.toLowerCase(): return "recharts";
+		case ClaudeArtifactMimeTypes.CHESS.toLowerCase(): return "chess";
+		case ClaudeArtifactMimeTypes.CODE.toLowerCase(): return "code";
+		case ClaudeArtifactMimeTypes.MARKDOWN.toLowerCase(): return "code";
+		case ClaudeArtifactMimeTypes.LATTICE.toLowerCase(): return "lattice";
+		case ClaudeArtifactMimeTypes.PYTHON.toLowerCase(): return "python";
+		case ClaudeArtifactMimeTypes.BLOG_DRAFT.toLowerCase(): return "blog-draft";
+	}
+	if (normalized.includes("jsx") || normalized.includes("react")) return "react";
+	if (normalized.includes("javascript") || normalized.includes("typescript")) return "code";
+	if (normalized.includes("python") || normalized === "text/x-python") return "python";
+	if (normalized.includes("java") || normalized.includes("c++") || normalized.includes("rust") || normalized.includes("go") || normalized.includes("ruby") || normalized.includes("php") || normalized.includes("swift") || normalized.includes("kotlin") || normalized.includes("csharp") || normalized.includes("c#")) return "code";
+	if (normalized.includes("html") || normalized.includes("xhtml")) return "html";
+	if (normalized.includes("svg")) return "svg";
+	if (normalized.includes("markdown") || normalized.includes("md")) return "code";
+	if (normalized.includes("mermaid")) return "mermaid";
+	if (normalized.includes("recharts") || normalized.includes("chart")) return "recharts";
+	if (normalized.includes("chess")) return "chess";
+	return null;
+}
 let KnowledgeType = /* @__PURE__ */ function(KnowledgeType) {
 	/**
 	* A knowledge that is from a URL.
@@ -1278,7 +1315,7 @@ const SreRepoConfigSchema = z.object({
 	/** Whether this repo's SRE pipeline is active */
 	enabled: z.boolean().default(false),
 	/** LLM model ID for Diagnostician */
-	modelId: z.string().default("claude-sonnet-4-20250514"),
+	modelId: z.string().default("claude-sonnet-4-6"),
 	/** Max diff lines per fix */
 	maxDiffLines: z.number().min(1).default(50),
 	/** Max fixes dispatched per day for this repo */
@@ -2663,7 +2700,8 @@ const AgentCompletedAction = z.object({
 	executionId: z.string(),
 	answer: z.string().optional(),
 	totalIterations: z.number(),
-	totalCreditsUsed: z.number()
+	totalCreditsUsed: z.number(),
+	mementoIds: z.array(z.string()).optional()
 });
 const AgentFailedAction = z.object({
 	action: z.literal("failed"),
@@ -3615,10 +3653,37 @@ const OpenAIImageStyleSchema = z.enum(["vivid", "natural"]);
 /**
 * Maps legacy/removed image model IDs to their current replacements.
 * Prevents Zod validation failures when clients send stale persisted model names.
+*
+* Values are constrained to `ALL_IMAGE_MODELS` so a remap target can never point at
+* a model that the schema would itself reject. If a target model is later retired,
+* re-point its entry to the current replacement rather than deleting it — clients may
+* still hold the legacy key in persisted state. When adding an entry, bump the
+* `llm-settings` persist `version` in LLMContext so existing clients re-run the remap.
+*
+* Only `flux-dev` is aliased among the recently removed Flux ids. It was a general
+* text-to-image model with a confirmed stale client (#8853), so remapping to the
+* current BFL standard is safe and faithful. `flux-pro-1.0-canny` and
+* `flux-pro-1.0-depth` are intentionally left as hard validation errors: they were
+* never UI-selectable (nothing persists them, and no alerts show callers sending them)
+* and they are structural-control models — silently remapping them to a plain
+* text-to-image model would drop the control image and return the wrong kind of result,
+* so a clear "unsupported model" error is the more honest response.
+*
+* The three `grok-2-image*` ids are the prior xAI image-model ids, all superseded
+* in the enum by `grok-imagine-image-quality`. The id went through an un-aliased
+* rename chain — `grok-2-image-1212` (original) → `grok-2-image` → `grok-2-image-gen`
+* → `grok-imagine-image-quality` — so any of the three could survive in stale
+* persisted client state (`grok-2-image-1212` was the one observed in #9211). All are
+* xAI text-to-image models, so remapping to the current id is a faithful
+* same-provider, same-modality replacement.
 */
 const LEGACY_IMAGE_MODEL_MAP = {
 	"dall-e-3": "gpt-image-1",
-	"dall-e-2": "gpt-image-1"
+	"dall-e-2": "gpt-image-1",
+	"flux-dev": "flux-pro-1.1",
+	"grok-2-image-1212": "grok-imagine-image-quality",
+	"grok-2-image": "grok-imagine-image-quality",
+	"grok-2-image-gen": "grok-imagine-image-quality"
 };
 const OpenAIImageGenerationInput = z.object({
 	prompt: z.string(),
@@ -3829,6 +3894,8 @@ z.enum([
 	"logoSettings",
 	"enforceCredits",
 	"enableTeamPlan",
+	"allowOpenRegistration",
+	"defaultFreeCredits",
 	"enableGoogleCalendar",
 	"googleCalendarServiceAccountEmail",
 	"googleCalendarServiceAccountSecret",
@@ -3913,8 +3980,36 @@ const OrchestrationDefaultsSchema = z.object({
 		"code_execute",
 		"coordinate_task"
 	]),
-	/** Tool names explicitly forbidden. Empty by default — `allowedTools` is the whitelist. */
-	deniedTools: z.array(z.string()).default([]),
+	/**
+	* Tool names explicitly forbidden. Enforced as a final subtraction in
+	* `pickEffectiveEnabledTools` — wins even over payload-pinned tools — so this
+	* is the defense-in-depth backstop for the case where an admin broadens
+	* `allowedTools` without realizing a parallel denylist is also needed.
+	*
+	* Seeded with every tool that mutates user data (#8945, the spec's
+	* "anything tagged `mutates_user_data`"): destructive/overwriting filesystem
+	* writes, arbitrary shell execution, blog authoring/publishing, persisted
+	* lattice-model writes, and storage-backed artifact generation. New mutating
+	* tools should be added here until the tag-derived denylist (Option B, #8923/
+	* #8924) replaces this hand-curated list.
+	*/
+	deniedTools: z.array(z.string()).default([
+		"create_file",
+		"edit_file",
+		"edit_local_file",
+		"delete_file",
+		"bash_execute",
+		"blog_draft",
+		"blog_edit",
+		"blog_publish",
+		"lattice_create_model",
+		"lattice_add_entity",
+		"lattice_set_value",
+		"lattice_create_rule",
+		"image_generation",
+		"edit_image",
+		"excel_generation"
+	]),
 	/** Per-thoroughness iteration ceiling. Matches `IAgent.maxIterations`. */
 	maxIterations: z.object({
 		quick: z.number().int().positive(),
@@ -5765,6 +5860,22 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.CREDITS.id,
 		category: "Users"
 	}),
+	allowOpenRegistration: makeBooleanSetting({
+		key: "allowOpenRegistration",
+		name: "Allow Open Registration",
+		defaultValue: false,
+		description: "Master switch for self-serve signup. When OFF (default), a valid invite code is required to register. When ON, users may register without an invite code; the Default Free Credits grant is then applied after they verify their email (anti-spam — see Default Free Credits). Safe to enable: the pre-request credit reservation caps every free user at the credits they are granted.",
+		group: API_SERVICE_GROUPS.CREDITS.id,
+		category: "Users"
+	}),
+	defaultFreeCredits: makeNumberSetting({
+		key: "defaultFreeCredits",
+		name: "Default Free Credits",
+		defaultValue: 0,
+		description: "Credits granted to a user who registers WITHOUT an invite code (only applies when Allow Open Registration is ON). Granted after the user verifies their email, NOT at signup — an unverified throwaway account gets 0 credits (anti-spam). A free user can never spend more than this — their hard ceiling of real model cost is roughly credits ÷ 1500 USD.",
+		group: API_SERVICE_GROUPS.CREDITS.id,
+		category: "Users"
+	}),
 	FacebookLink: makeStringSetting({
 		key: "FacebookLink",
 		name: "Facebook Link",
@@ -7229,6 +7340,13 @@ const PromptMetaZodSchema = z.object({
 	generatedImageReferences: z.array(z.string()).optional(),
 	promptErrors: z.array(z.string()).optional(),
 	warnings: z.array(z.string()).optional(),
+	/**
+	* The provider's reason for ending generation (Anthropic vocabulary:
+	* 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | 'pause_turn').
+	* 'max_tokens' signals the response was truncated against the output ceiling,
+	* letting the client render a truncated-artifact recovery affordance (#9259).
+	*/
+	finishReason: z.string().optional(),
 	statusLog: z.array(z.object({
 		status: z.string(),
 		timestamp: z.date().or(z.string())
@@ -7950,12 +8068,14 @@ z$1.object({
 	slug: z$1.string().min(2).max(60).regex(slugRegex, "Slug must be lowercase alphanumeric with hyphens (e.g. \"my-data-lake\")"),
 	description: z$1.string().max(2e3).optional(),
 	fileTagPrefix: z$1.string().min(2).max(30).refine((s) => s.endsWith(":"), "Tag prefix must end with \":\" (e.g. \"acme:\")"),
-	requiredUserTag: z$1.string().min(1).max(100).optional()
+	requiredUserTag: z$1.string().min(1).max(100).optional(),
+	requiredEntitlement: z$1.string().min(3).max(100).refine((s) => s.includes(":") && s.split(":").every((part) => part.length > 0), "Entitlement key must be namespaced with non-empty parts (e.g. \"product:pro\")").optional()
 });
 z$1.object({
 	name: z$1.string().min(1).max(200).optional(),
 	description: z$1.string().max(2e3).optional(),
-	requiredUserTag: z$1.string().min(1).max(100).optional()
+	requiredUserTag: z$1.string().min(1).max(100).optional(),
+	requiredEntitlement: z$1.string().min(3).max(100).refine((s) => s.includes(":") && s.split(":").every((part) => part.length > 0), "Entitlement key must be namespaced with non-empty parts (e.g. \"product:pro\")").optional()
 });
 z$1.object({
 	organizationId: z$1.string().optional(),
@@ -8101,37 +8221,68 @@ const DATA_LAKES = [{
 	id: "ionq-sales",
 	name: "IonQ Sales Intelligence",
 	requiredUserTag: "Opti",
+	requiredEntitlement: "optihashi:pro",
 	fileTagPrefix: "ionq:",
 	datalakeTag: "datalake:ionq-sales"
 }, {
 	id: "opti-knowledge",
 	name: "Optimization Knowledge Base",
 	requiredUserTag: "Opti",
+	requiredEntitlement: "optihashi:pro",
 	fileTagPrefix: "opti:",
 	datalakeTag: "datalake:opti-knowledge"
 }];
 /**
-* Returns data lakes accessible to a user based on their tags.
-* Data lakes without a requiredUserTag are accessible to all authenticated users.
-* When dynamicDataLakes is provided (fetched from DB), those take precedence
-* over hardcoded DATA_LAKES entries with the same id.
+* Canonical normalization for entitlement keys + `requiredEntitlement` values — the ONE
+* rule, applied at write time (create/update/stamp) and at match time. Mirrors the
+* entitlement registry's `normalizeTag` (trim + lowercase) so a value authored in any
+* casing matches the lowercase keys the resolver produces.
+*/
+const normalizeEntitlementKey = (key) => key.trim().toLowerCase();
+/**
+* Single projection from a persisted lake document to the lightweight DataLakeConfig
+* the access filters operate on. Centralized so the `requiredEntitlement` field (and any
+* future field) cannot be silently dropped at one of the many former inline projections.
+*/
+function toDataLakeConfig(dl) {
+	return {
+		id: dl.id,
+		name: dl.name,
+		requiredUserTag: dl.requiredUserTag,
+		requiredEntitlement: dl.requiredEntitlement,
+		fileTagPrefix: dl.fileTagPrefix,
+		datalakeTag: dl.datalakeTag
+	};
+}
+/**
+* Returns data lakes accessible to a user.
+*
+* Access rule (generic, any-of declared requirements): a lake is accessible iff it
+* declares NO access requirement, OR the user satisfies ANY declared requirement —
+* either `requiredUserTag` (matched against the user's tags) or `requiredEntitlement`
+* (matched against the caller's resolved `entitlementKeys`). A lake declaring an
+* entitlement but no tag is therefore NOT public (it is gated by the key).
+*
+* Data lakes without any requirement are accessible to all authenticated users.
+* When dynamicDataLakes is provided (fetched from DB), those take precedence over
+* hardcoded DATA_LAKES entries with the same id. `entitlementKeys` is optional — callers
+* that don't resolve entitlements (tag-only surfaces) omit it and get tag-only matching.
 */
-function getAccessibleDataLakes(userTags, dynamicDataLakes) {
+function getAccessibleDataLakes(userTags, dynamicDataLakes, entitlementKeys) {
 	const normalizedUserTags = userTags.map((tag) => tag.toLowerCase());
+	const normalizedKeys = (entitlementKeys ?? []).map(normalizeEntitlementKey);
 	let allLakes;
 	if (dynamicDataLakes && dynamicDataLakes.length > 0) {
 		const dynamicIds = new Set(dynamicDataLakes.map((d) => d.id));
 		const fallbacks = DATA_LAKES.filter((dl) => !dynamicIds.has(dl.id));
 		allLakes = [...dynamicDataLakes, ...fallbacks];
 	} else allLakes = DATA_LAKES;
-	return allLakes.filter((dl) => !dl.requiredUserTag || normalizedUserTags.includes(dl.requiredUserTag.toLowerCase()));
-}
-/**
-* Returns the datalake: meta-tags for all data lakes a user can access.
-* Pass dynamicDataLakes from DB for runtime-registered data lakes.
-*/
-function getDataLakeTags(userTags, dynamicDataLakes) {
-	return getAccessibleDataLakes(userTags, dynamicDataLakes).map((dl) => dl.datalakeTag);
+	return allLakes.filter((dl) => {
+		if (!(!!dl.requiredUserTag || !!dl.requiredEntitlement)) return true;
+		const tagMatch = !!dl.requiredUserTag && normalizedUserTags.includes(dl.requiredUserTag.toLowerCase());
+		const entMatch = !!dl.requiredEntitlement && normalizedKeys.includes(normalizeEntitlementKey(dl.requiredEntitlement));
+		return tagMatch || entMatch;
+	});
 }
 /**
 * Jupyter Kernel Constants and Validation
@@ -8284,6 +8435,8 @@ z.object({
 	/** Notebook session ID */
 	sessionId: z.string(),
 	historyCount: z.number(),
+	/** Epoch ms when the client submitted the prompt (for the request-lifecycle status log). */
+	clientSubmittedAt: z.number().optional(),
 	imageConfig: GenerateImageToolCallSchema.optional(),
 	deepResearchConfig: z.object({
 		maxDepth: z.number().optional(),
@@ -8564,6 +8717,114 @@ BaseArtifactSchema.extend({
 	})
 });
 /**
+* Annotation schemas — the collaboration layer that sits on top of a
+* PublishedArtifact. An annotation is a structured input keyed to an artifact
+* by its `publicId`. The `kind` discriminator is deliberately generic: v1 ships
+* only `comment`, but `approval`/`vote`/`signature` are reserved so the layer
+* can grow into approval workflows and e-signature without a model migration.
+*
+* Anchoring is PINS-FIRST: an annotation may carry normalized viewport
+* coordinates (0..1) and a best-effort CSS selector. Robust element-range
+* anchoring is deferred. An annotation with no anchor is document-level.
+*
+* Every annotation records the artifact version it was made against
+* (`artifactVersionSha`, the artifact's `sha256Index` at the time) so feedback
+* stays pinned to the version it critiqued — this is also the input the AI
+* revision loop (Phase C) consumes.
+*/
+const AnnotationKindSchema = z.enum([
+	"comment",
+	"approval",
+	"vote",
+	"signature"
+]);
+/** Owner-controlled gate on WHO may annotate, orthogonal to artifact visibility
+*  (which controls who may VIEW). `none` = read-only (today's behavior, default).
+*  `open` = any authenticated viewer who passes the visibility gate. `restricted`
+*  = owner + explicit allowlist (allowlist UI deferred). */
+const CommentPolicySchema = z.enum([
+	"none",
+	"open",
+	"restricted"
+]);
+const AnnotationAnchorSchema = z.object({
+	/** Normalized horizontal position within the artifact viewport, 0..1. */
+	x: z.number().min(0).max(1).optional(),
+	/** Normalized vertical position within the artifact document, 0..1. */
+	y: z.number().min(0).max(1).optional(),
+	/** Best-effort CSS selector path captured by the widget (may be stale). */
+	selector: z.string().max(1024).optional(),
+	/** Optional scroll-section label / fragment the pin was dropped in. */
+	scrollSection: z.string().max(256).optional()
+});
+const AnnotationPayloadSchema = z.object({
+	/** kind === 'approval' */
+	decision: z.enum(["approve", "reject"]).optional(),
+	/** kind === 'vote' */
+	choice: z.string().max(256).optional(),
+	/** kind === 'signature' */
+	signedName: z.string().max(200).optional(),
+	signatureHash: z.string().max(128).optional()
+}).optional();
+const ANNOTATION_BODY_MAX = 5e3;
+z.object({
+	id: z.string(),
+	/** FK → PublishedArtifact.publicId. */
+	publicId: z.string(),
+	/** PublishedArtifact.sha256Index at the time the annotation was made. */
+	artifactVersionSha: z.string().optional(),
+	kind: AnnotationKindSchema.prefault("comment"),
+	authorId: z.string(),
+	/** Denormalized for render — annotation authorship is immutable. */
+	authorDisplayName: z.string().max(200),
+	body: z.string().max(ANNOTATION_BODY_MAX),
+	anchor: AnnotationAnchorSchema.optional(),
+	/** null/absent = top-level; else this is a reply to another annotation. */
+	threadRootId: z.string().nullish(),
+	payload: AnnotationPayloadSchema,
+	resolvedAt: z.date().nullish(),
+	resolvedBy: z.string().nullish(),
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	deletedAt: z.date().nullish(),
+	deletedBy: z.string().nullish()
+});
+z.object({
+	body: z.string().min(1).max(ANNOTATION_BODY_MAX),
+	/** v1 accepts only 'comment'; defaulted server-side. */
+	kind: AnnotationKindSchema.optional(),
+	anchor: AnnotationAnchorSchema.optional(),
+	threadRootId: z.string().optional(),
+	artifactVersionSha: z.string().optional(),
+	payload: AnnotationPayloadSchema
+});
+z.object({
+	body: z.string().min(1).max(ANNOTATION_BODY_MAX).optional(),
+	/** Toggle resolution. true → resolve, false → reopen. */
+	resolved: z.boolean().optional()
+}).refine((v) => v.body !== void 0 || v.resolved !== void 0, { message: "Nothing to update" });
+const AnnotationDtoSchema = z.object({
+	id: z.string(),
+	publicId: z.string(),
+	kind: AnnotationKindSchema,
+	authorId: z.string(),
+	authorDisplayName: z.string(),
+	body: z.string(),
+	anchor: AnnotationAnchorSchema.optional(),
+	threadRootId: z.string().nullish(),
+	payload: AnnotationPayloadSchema,
+	artifactVersionSha: z.string().optional(),
+	resolvedAt: z.string().nullish(),
+	createdAt: z.string()
+});
+z.object({
+	annotations: z.array(AnnotationDtoSchema),
+	/** Echoed so the widget can render the right affordance without a 2nd call. */
+	commentPolicy: CommentPolicySchema,
+	/** Whether the CURRENT caller may create an annotation right now. */
+	canComment: z.boolean()
+});
+/**
 * Published-artifact schemas — the B4M instantiation of the `artifact-publishing`
 * blueprint (MillionOnMars/blueprints, extracted from Polaris Publish v1).
 *
@@ -8645,6 +8906,9 @@ z.object({
 	visibility: VisibilitySchema.prefault("private"),
 	/** Group id a viewer must belong to when gated cross-scope. */
 	gatedToGroupId: z.string().optional(),
+	/** Collaboration gate: who (among viewers) may annotate. Orthogonal to
+	*  `visibility`. Defaults to `none` (read-only) until the owner opts in. */
+	commentPolicy: CommentPolicySchema.prefault("none"),
 	ownerId: z.string(),
 	lastPublishedBy: z.string().optional(),
 	source: PublishSourceSchema,
@@ -8662,6 +8926,8 @@ z.object({
 	publishedAt: z.date(),
 	previousVersionMeta: ArtifactVersionMetaSchema.optional(),
 	viewCount: z.int().nonnegative().prefault(0),
+	/** Concurrency lock for AI revise (set while a revision is in flight). */
+	revisingAt: z.date().nullish(),
 	createdAt: z.date(),
 	updatedAt: z.date(),
 	deletedAt: z.date().nullish(),
@@ -8696,6 +8962,8 @@ z.object({
 	description: z.string().max(1e3).optional(),
 	visibility: VisibilitySchema.optional(),
 	gatedToGroupId: z.string().optional(),
+	/** Who may annotate the published artifact. Defaults to `none` (read-only). */
+	commentPolicy: CommentPolicySchema.optional(),
 	source: PublishSourceSchema.optional(),
 	files: z.array(FileDescriptorSchema).min(1).max(PUBLISH_LIMITS.maxFiles)
 });
@@ -8851,6 +9119,33 @@ function isGPTImage2Model(model) {
 	return model === "gpt-image-2" || model.startsWith("gpt-image-2");
 }
 /**
+* Whether a user can access a model. Access is any-of (mirrors the Q3b data-lake
+* rule, `getAccessibleDataLakes`): a non-admin reaches the model via
+* `allowedUserTags ∩ userTags` OR `allowedEntitlements ∩ entitlementKeys`.
+*
+* `entitlementKeys` is optional — when omitted/empty the entitlement branch is
+* inert, so a model with no `allowedEntitlements` behaves exactly as before
+* (tag-only). This lets a tag-less subscriber reach an entitlement-gated model
+* while leaving every existing tag-gated model unchanged (zero regression).
+*
+* Pure + zero-dependency (only types + the shared key normalizer), so it lives
+* in `@bike4mind/common` as the SINGLE source of truth — imported by the core
+* `@bike4mind/utils` re-export (server/services) AND the client
+* `useAccessibleModels` hook, which previously kept a hand-rolled twin "to avoid
+* AWS SDK imports". Common is browser-safe, so there is no longer any reason to
+* duplicate the logic.
+*/
+function isModelAccessible(model, userTags, isAdmin = false, entitlementKeys = []) {
+	if (!model.enabled) return false;
+	if (isAdmin) return true;
+	const normalizedUserTags = userTags.map((tag) => tag.toLowerCase());
+	const normalizedAllowedTags = (model.allowedUserTags ?? []).map((tag) => tag.toLowerCase());
+	if (normalizedUserTags.some((tag) => normalizedAllowedTags.includes(tag))) return true;
+	const normalizedKeys = entitlementKeys.map(normalizeEntitlementKey);
+	const normalizedAllowedEntitlements = (model.allowedEntitlements ?? []).map(normalizeEntitlementKey);
+	return normalizedKeys.some((key) => normalizedAllowedEntitlements.includes(key));
+}
+/**
 * Telemetry Error Sanitizer
 *
 * Removes PII (Personally Identifiable Information) from error messages
@@ -8976,6 +9271,67 @@ z.array(triggerWordSchema).max(20, "Up to 20 trigger words allowed.").transform(
 	}
 	return out;
 });
+/**
+* Skill body argument substitution. Shared by the server-side SkillsFeature,
+* the LLM `skill` tool, and the CLI's skill executor so the same patterns
+* resolve identically across surfaces.
+*
+* Supports Claude Code's substitution syntax:
+*   - `$ARGUMENTS` — all positional args joined by spaces
+*   - `$1`, `$2`, ... — individual positional args
+*
+* Why a shared helper: the CLI already implemented this in
+* `apps/cli/src/utils/argumentSubstitution.ts`. Centralizing here avoids a
+* second drift surface — a skill body authored on the web and run in the CLI
+* (or vice versa) must expand identically.
+*/
+function substituteArguments(template, args) {
+	let result = template;
+	for (let i = args.length; i >= 1; i--) {
+		const pattern = new RegExp(`\\$${i}`, "g");
+		result = result.replace(pattern, args[i - 1] ?? "");
+	}
+	return result.replace(/\$ARGUMENTS/g, args.join(" "));
+}
+/**
+* Shell-style argument splitter — supports double / single quotes for
+* grouping. Identical semantics to the CLI's `parseArguments`.
+*
+*   parseSkillArguments('hello world')               => ['hello', 'world']
+*   parseSkillArguments('"hello world" test')        => ['hello world', 'test']
+*   parseSkillArguments("'one two' three")           => ['one two', 'three']
+*   parseSkillArguments('')                          => []
+*
+* Unclosed quotes are forgiven, not flagged: `parseSkillArguments('"unclosed')`
+* returns `['unclosed']`. This matches the CLI's pre-existing behavior and is
+* deliberate — skills are user-authored prose, not a shell, and surfacing a
+* parse error for a stray `"` would punish a typo more than the cost of a
+* slightly-wrong split warrants.
+*/
+function parseSkillArguments(input) {
+	if (!input) return [];
+	const args = [];
+	let current = "";
+	let inQuotes = false;
+	let quoteChar = "";
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		if (!inQuotes && (char === "\"" || char === "'")) {
+			inQuotes = true;
+			quoteChar = char;
+		} else if (inQuotes && char === quoteChar) {
+			inQuotes = false;
+			quoteChar = "";
+		} else if (!inQuotes && /\s/.test(char)) {
+			if (current.length > 0) {
+				args.push(current);
+				current = "";
+			}
+		} else current += char;
+	}
+	if (current.length > 0) args.push(current);
+	return args;
+}
 const VIEW_REGISTRY = [
 	{
 		id: "opti.root",
@@ -10238,11 +10594,32 @@ const ApiConfigSchema = z.object({ customUrl: z.url().optional() });
 */
 const McpServerSchema = z.object({
 	name: z.string(),
+	type: z.enum(["stdio", "http"]).optional(),
 	command: z.string().optional(),
 	args: z.array(z.string()).optional(),
+	url: z.string().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
 	env: z.record(z.string(), z.string()).prefault({}),
 	enabled: z.boolean().prefault(true)
-});
+}).superRefine(mcpServerTransportRefine);
+/**
+* A valid MCP server is exactly one of:
+*  - stdio: has `command` (spawned child process)
+*  - http:  has `url` (streamable-HTTP endpoint)
+* Rejecting malformed configs at parse time (not connect time) surfaces errors early.
+*/
+function mcpServerTransportRefine(server, ctx) {
+	const hasCommand = typeof server.command === "string" && server.command.trim() !== "";
+	const hasUrl = typeof server.url === "string" && server.url.trim() !== "";
+	if (hasCommand && hasUrl) ctx.addIssue({
+		code: "custom",
+		message: "MCP server cannot set both \"command\" (stdio) and \"url\" (http)"
+	});
+	else if (!hasCommand && !hasUrl) ctx.addIssue({
+		code: "custom",
+		message: "MCP server must set either \"command\" (stdio) or \"url\" (http)"
+	});
+}
 /**
 * MCP Servers can be specified in two formats:
 * 1. Array format (B4M native): [{ "name": "...", "command": "...", ... }]
@@ -10251,11 +10628,14 @@ const McpServerSchema = z.object({
 * Both formats are supported for maximum flexibility and compatibility.
 */
 const McpServersSchema = z.union([z.array(McpServerSchema), z.record(z.string(), z.object({
+	type: z.enum(["stdio", "http"]).optional(),
 	command: z.string().optional(),
 	args: z.array(z.string()).optional(),
+	url: z.string().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
 	env: z.record(z.string(), z.string()).optional(),
 	enabled: z.boolean().optional()
-}))]);
+}).superRefine(mcpServerTransportRefine))]);
 /**
 * Normalize MCP servers to internal array format
 * Accepts both array and object formats
@@ -10263,15 +10643,21 @@ const McpServersSchema = z.union([z.array(McpServerSchema), z.record(z.string(),
 function normalizeMcpServers(servers) {
 	if (Array.isArray(servers)) return servers.map((server) => ({
 		name: server.name,
+		type: server.type,
 		command: server.command,
 		args: server.args,
+		url: server.url,
+		headers: server.headers,
 		env: server.env || {},
 		enabled: server.enabled ?? true
 	}));
 	else return Object.entries(servers).map(([name, config]) => ({
 		name,
+		type: config.type,
 		command: config.command,
 		args: config.args,
+		url: config.url,
+		headers: config.headers,
 		env: config.env || {},
 		enabled: config.enabled ?? true
 	}));
@@ -10302,6 +10688,14 @@ const CliConfigSchema = z.object({
 		exportFormat: z.enum(["markdown", "json"]),
 		maxIterations: z.number().nullable().prefault(10),
 		enableSkillTool: z.boolean().optional().prefault(true),
+		/**
+		* When false (or set via the `--no-remote-skills` CLI flag / the
+		* `B4M_NO_REMOTE_SKILLS=1` env var), the CLI skips fetching skills from
+		* the B4M backend's `/api/skills` endpoint and runs with local files only.
+		* Defaults to true so authenticated users get cross-machine skill sync
+		* out of the box.
+		*/
+		enableRemoteSkills: z.boolean().optional().prefault(true),
 		enableDynamicAgentCreation: z.boolean().optional().prefault(false),
 		enableCoordinatorMode: z.boolean().optional().prefault(false),
 		/**
@@ -10393,6 +10787,7 @@ const DEFAULT_CONFIG = {
 		exportFormat: "markdown",
 		maxIterations: 10,
 		enableSkillTool: true,
+		enableRemoteSkills: true,
 		enableDynamicAgentCreation: false,
 		enableCoordinatorMode: false,
 		promptVariant: "current"
@@ -10503,6 +10898,29 @@ async function loadMcpJsonConfig(projectDir) {
 	}
 }
 /**
+* Load an explicit `--mcp-config <file>` (claude shape: `{ "mcpServers": {...} }`).
+* Unlike `.mcp.json` this is an absolute path passed at launch, not project-relative.
+* Returns null on missing/malformed file (a bad config must not brick the launch).
+*/
+async function loadMcpConfigFile(filePath) {
+	try {
+		const data = await promises.readFile(filePath, "utf-8");
+		const rawConfig = JSON.parse(data);
+		return normalizeMcpServers(McpJsonConfigSchema.parse(rawConfig).mcpServers);
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			console.error(`--mcp-config file not found: ${filePath}`);
+			return null;
+		}
+		if (error instanceof z.ZodError) {
+			console.error("--mcp-config validation error:", error.issues);
+			return null;
+		}
+		console.error("Failed to load --mcp-config file:", error);
+		return null;
+	}
+}
+/**
 * Merge MCP servers from multiple configs
 * Later configs can override earlier ones by name
 */
@@ -10684,6 +11102,12 @@ var ConfigStore = class {
 			} else this.projectConfigDir = null;
 			const mergedConfig = mergeConfigs(globalConfig, projectConfig, projectLocalConfig);
 			if (mcpJsonServers && mcpJsonServers.length > 0) mergedConfig.mcpServers = mergeMcpServers(mcpJsonServers, mergedConfig.mcpServers);
+			const mcpConfigFile = process.env.B4M_MCP_CONFIG_FILE;
+			if (mcpConfigFile) {
+				const injected = await loadMcpConfigFile(mcpConfigFile);
+				if (process.env.B4M_STRICT_MCP_CONFIG === "1") mergedConfig.mcpServers = injected ?? [];
+				else if (injected) mergedConfig.mcpServers = mergeMcpServers(mergedConfig.mcpServers, injected);
+			}
 			this.config = mergedConfig;
 			return this.config;
 		} catch (error) {
@@ -11030,4 +11454,4 @@ var ConfigStore = class {
 	}
 };
 //#endregion
-export { ProjectEvents as $, GenerateImageToolCallSchema as A, dayjsConfig_default as At, InviteEvents as B, resolveNavigationIntents as Bt, ElabsEvents as C, UnauthorizedError as Ct, ForbiddenError as D, VideoModels as Dt, FileEvents as E, VideoGenerationUsageTransaction as Et, ImageEditUsageTransaction as F, isGPTImage2Model as Ft, ModalEvents as G, validateNotebookPath as Gt, KnowledgeType as H, secureParameters as Ht, ImageGenerationUsageTransaction as I, isGPTImageModel as It, OpenAIEmbeddingModel as J, isNearLimit as Jt, ModelBackend as K, buildRateLimitLogEntry as Kt, ImageModels as L, isSupportedEmbeddingModel as Lt, GenericCreditDeductTransaction as M, getDataLakeTags as Mt, HTTPError as N, getMcpProviderMetadata as Nt, FriendshipEvents as O, XAI_IMAGE_MODELS as Ot, HttpStatus as P, getViewById as Pt, ProfileEvents as Q, InboxEvents as R, isZodError as Rt, DashboardParamsSchema as S, UiNavigationEvents as St, FeedbackEvents as T, VIDEO_SIZE_CONSTRAINTS as Tt, LLMEvents as U, settingsMap as Ut, InviteType as V, sanitizeTelemetryError as Vt, MiscEvents as W, validateJupyterKernelName as Wt, Permission as X, CollectionType as Xt, OpenAIImageGenerationInput as Y, parseRateLimitHeaders as Yt, PermissionDeniedError as Z, ChatCompletionCreateInputSchema as _, TaskScheduleHandler as _t, ALERT_THRESHOLDS as a, ReceivedCreditTransaction as at, CompletionApiUsageTransaction as b, ToolUsageTransaction as bt, ApiKeyScope as c, ResearchModeParamsSchema as ct, ArtifactTypeSchema as d, ResearchTaskType as dt, PromptIntentSchema as et, AuthEvents as f, SessionEvents as ft, CREDIT_DEDUCT_TRANSACTION_TYPES as g, TagType as gt, BadRequestError as h, SupportedFabFileMimeTypes as ht, getEnvironmentName as i, RealtimeVoiceUsageTransaction as it, GenericCreditAddTransaction as j, getAccessibleDataLakes as jt, GEMINI_IMAGE_MODELS as k, b4mLLMTools as kt, ApiKeyType as l, ResearchTaskExecutionType as lt, BFL_SAFETY_TOLERANCE as m, SubscriptionCreditTransaction as mt, logger as n, PurchaseTransaction as nt, AiEvents as o, RechartsChartTypeList as ot, BFL_IMAGE_MODELS as p, SpeechToTextUsageTransaction as pt, NotFoundError as q, extractSnippetMeta as qt, getApiUrl as r, QuestMasterParamsSchema as rt, ApiKeyEvents as s, RegInviteEvents as st, ConfigStore as t, PromptMetaZodSchema as tt, AppFileEvents as u, ResearchTaskPeriodicFrequencyType as ut, ChatModels as v, TextGenerationUsageTransaction as vt, FavoriteDocumentType as w, UnprocessableEntityError as wt, CorruptedFileError as x, TransferCreditTransaction as xt, ClaudeArtifactMimeTypes as y, TooManyRequestsError as yt, InternalServerError as z, obfuscateApiKey as zt };
+export { ProjectEvents as $, parseRateLimitHeaders as $t, GenerateImageToolCallSchema as A, dayjsConfig_default as At, InviteEvents as B, obfuscateApiKey as Bt, ElabsEvents as C, UnauthorizedError as Ct, ForbiddenError as D, VideoModels as Dt, FileEvents as E, VideoGenerationUsageTransaction as Et, ImageEditUsageTransaction as F, isGPTImageModel as Ft, ModalEvents as G, settingsMap as Gt, KnowledgeType as H, resolveNavigationIntents as Ht, ImageGenerationUsageTransaction as I, isModelAccessible as It, OpenAIEmbeddingModel as J, validateJupyterKernelName as Jt, ModelBackend as K, substituteArguments as Kt, ImageModels as L, isSupportedEmbeddingModel as Lt, GenericCreditDeductTransaction as M, getMcpProviderMetadata as Mt, HTTPError as N, getViewById as Nt, FriendshipEvents as O, XAI_IMAGE_MODELS as Ot, HttpStatus as P, isGPTImage2Model as Pt, ProfileEvents as Q, isNearLimit as Qt, InboxEvents as R, isZodError as Rt, DashboardParamsSchema as S, UiNavigationEvents as St, FeedbackEvents as T, VIDEO_SIZE_CONSTRAINTS as Tt, LLMEvents as U, sanitizeTelemetryError as Ut, InviteType as V, parseSkillArguments as Vt, MiscEvents as W, secureParameters as Wt, Permission as X, buildRateLimitLogEntry as Xt, OpenAIImageGenerationInput as Y, validateNotebookPath as Yt, PermissionDeniedError as Z, extractSnippetMeta as Zt, ChatCompletionCreateInputSchema as _, TaskScheduleHandler as _t, ALERT_THRESHOLDS as a, ReceivedCreditTransaction as at, CompletionApiUsageTransaction as b, ToolUsageTransaction as bt, ApiKeyScope as c, ResearchModeParamsSchema as ct, ArtifactTypeSchema as d, ResearchTaskType as dt, CollectionType as en, PromptIntentSchema as et, AuthEvents as f, SessionEvents as ft, CREDIT_DEDUCT_TRANSACTION_TYPES as g, TagType as gt, BadRequestError as h, SupportedFabFileMimeTypes as ht, getEnvironmentName as i, RealtimeVoiceUsageTransaction as it, GenericCreditAddTransaction as j, getAccessibleDataLakes as jt, GEMINI_IMAGE_MODELS as k, b4mLLMTools as kt, ApiKeyType as l, ResearchTaskExecutionType as lt, BFL_SAFETY_TOLERANCE as m, SubscriptionCreditTransaction as mt, logger as n, PurchaseTransaction as nt, AiEvents as o, RechartsChartTypeList as ot, BFL_IMAGE_MODELS as p, SpeechToTextUsageTransaction as pt, NotFoundError as q, toDataLakeConfig as qt, getApiUrl as r, QuestMasterParamsSchema as rt, ApiKeyEvents as s, RegInviteEvents as st, ConfigStore as t, PromptMetaZodSchema as tt, AppFileEvents as u, ResearchTaskPeriodicFrequencyType as ut, ChatModels as v, TextGenerationUsageTransaction as vt, FavoriteDocumentType as w, UnprocessableEntityError as wt, CorruptedFileError as x, TransferCreditTransaction as xt, ClaudeArtifactMimeTypes as y, TooManyRequestsError as yt, InternalServerError as z, mapMimeTypeToArtifactType as zt };