@cmmd-center/forge 0.9.16 → 0.9.17

package/dist/bin.cjs

@@ -22345,6 +22345,40 @@ const ServerProviderAuth = require_Schema$1.Struct({
 	accountEmail: require_Schema$1.optional(TrimmedNonEmptyString),
 	provenance: require_Schema$1.optional(ProviderAuthProvenance)
 });
+/**
+* Whether this Environment will let a person select the provider.
+*
+* Published for every provider the build knows about. A provider is never
+* dropped from the list: absence is not a state, and four different reasons
+* once collapsed into one "Coming soon." string because the Shell had to infer
+* meaning from what was missing. See
+* `docs/adr/withheld-providers-carry-their-reason.md`.
+*/
+const ProviderAvailability = require_Schema$1.Literals(["available", "unavailable"]);
+/**
+* Why a Withheld Provider is withheld. The four members are the glossary's,
+* in `CONTEXT.md` section "Provider availability": Unbuilt, Not Offered, Not
+* Usable, Not on this Environment. Only Unbuilt may read "Coming soon."
+*
+* An Environment can only ever report Unbuilt, Not Usable, or Not on this
+* Environment. Not Offered is a CMMD fact about the organization's Provider
+* Offer, which the Shell adds when it joins.
+*/
+const ProviderUnavailableReason = require_Schema$1.Literals([
+	"unbuilt",
+	"not-offered",
+	"not-usable",
+	"not-on-this-environment"
+]);
+/**
+* The Not Usable sub-case. It picks a second line of copy, not a fifth state,
+* which is why it is a separate field rather than three more reasons.
+*/
+const ProviderUnavailableDetail = require_Schema$1.Literals([
+	"no-connection",
+	"delivery-pending",
+	"reconnect-required"
+]);
 const ServerProviderModel = require_Schema$1.Struct({
 	slug: TrimmedNonEmptyString,
 	name: TrimmedNonEmptyString,
@@ -22376,6 +22410,9 @@ const ServerProvider = require_Schema$1.Struct({
 	checkedAt: IsoDateTime,
 	message: require_Schema$1.optional(TrimmedNonEmptyString),
 	models: require_Schema$1.ArraySchema(ServerProviderModel),
+	availability: require_Schema$1.optional(ProviderAvailability),
+	unavailableReason: require_Schema$1.optional(ProviderUnavailableReason),
+	unavailableDetail: require_Schema$1.optional(ProviderUnavailableDetail),
 	slashCommands: require_Schema$1.ArraySchema(ServerProviderSlashCommand).pipe(require_Schema$1.withDecodingDefault(require_Schema$1.succeed([]))),
 	skills: require_Schema$1.ArraySchema(ServerProviderSkill).pipe(require_Schema$1.withDecodingDefault(require_Schema$1.succeed([])))
 });
@@ -65123,7 +65160,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.9.16";
+var version$1 = "0.9.17";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -285043,14 +285080,87 @@ const writeProviderStatusCache = (input) => {
 	})));
 };
 //#endregion
-//#region src/provider/Layers/ProviderRegistry.ts
+//#region ../../packages/shared/src/providerExecution.ts
+/**
+* Canonical provider-readiness gate for starting work.
+*
+* Cloud user VMs can execute through Forge's scoped provider proxy without a
+* provider-local login. In that case the provider reports unauthenticated but
+* its credential provenance is explicitly `proxied`.
+*/
+function isServerProviderExecutable(provider) {
+	const hasExecutionAuthority = provider.auth.status !== "unauthenticated" || provider.auth.provenance?.credentialScope === "proxied";
+	return provider.enabled && provider.installed && provider.status === "ready" && hasExecutionAuthority && provider.models.length > 0;
+}
+//#endregion
+//#region src/provider/providerAvailability.ts
 /**
-* Providers surfaced in the UI but lacking a dedicated detection Layer.
-* Every provider now has a real Layer; this array stays as a (currently
-* empty) hook for any future provider that ships in the UI before its
-* server-side detection lands.
+* Derive what this Environment knows about a provider's availability.
+*
+* WHY THIS EXISTS
+*
+* Four different states (Unbuilt, Not Offered, Not Usable, Not on this
+* Environment) used to render as one "Coming soon." string, because consumers
+* were handed a filtered list and had to infer meaning from what was missing.
+* Every provider is now published with an explicit availability and, when
+* withheld, its reason. See `docs/adr/withheld-providers-carry-their-reason.md`
+* and the glossary in `CONTEXT.md` section "Provider availability".
+*
+* WHAT AN ENVIRONMENT MAY SAY
+*
+* Three of the four reasons only. Not Offered is a fact about the CMMD
+* organization's Provider Offer, and delivery-pending is a fact about a
+* credential in flight; neither is visible from inside an Environment, so the
+* Shell adds them when it joins. Nothing here may invent them.
+*
+* This reads the snapshot a provider Layer already produced. It runs no probe
+* and changes no probe: `isServerProviderExecutable` stays the single gate on
+* whether a turn can be dispatched, and this restates its answer in the
+* vocabulary a person sees.
 */
-const STUB_PROVIDERS = [];
+/**
+* Providers Forge ships in the UI but cannot execute, published as Unbuilt.
+*
+* Empty in this build: codex, claudeAgent, ollama, cmmd, apex, cursor and
+* opencode all have a real detection Layer and a registered adapter. The list
+* stays as the one place a provider that ships ahead of its server-side
+* implementation is named, so "Coming soon." is a deliberate entry rather than
+* a fallback something fell into.
+*/
+const UNBUILT_PROVIDERS = [];
+function deriveProviderAvailability(provider, unbuiltProviders = UNBUILT_PROVIDERS) {
+	if (unbuiltProviders.includes(provider.provider)) return {
+		availability: "unavailable",
+		unavailableReason: "unbuilt"
+	};
+	if (isServerProviderExecutable(provider)) return { availability: "available" };
+	const hasProxiedCredential = provider.auth.provenance?.credentialScope === "proxied";
+	if (provider.installed && provider.auth.status === "unauthenticated" && !hasProxiedCredential) return {
+		availability: "unavailable",
+		unavailableReason: "not-usable",
+		unavailableDetail: "no-connection"
+	};
+	return {
+		availability: "unavailable",
+		unavailableReason: "not-on-this-environment"
+	};
+}
+/**
+* Stamp a snapshot with its derived availability.
+*
+* The previous fields are dropped before the new ones are applied. Merging
+* would leave a provider that just connected reporting `available` while still
+* carrying the reason it was withheld for.
+*/
+function withProviderAvailability(provider, unbuiltProviders = UNBUILT_PROVIDERS) {
+	const { availability: _availability, unavailableReason: _unavailableReason, unavailableDetail: _unavailableDetail, ...rest } = provider;
+	return {
+		...rest,
+		...deriveProviderAvailability(provider, unbuiltProviders)
+	};
+}
+//#endregion
+//#region src/provider/Layers/ProviderRegistry.ts
 const loadProviders = (codexProvider, claudeProvider, ollamaProvider, cmmdProvider, apexProvider, cursorProvider, opencodeProvider) => require_Schema$1.all([
 	codexProvider.getSnapshot,
 	claudeProvider.getSnapshot,
@@ -285087,9 +285197,9 @@ const ProviderRegistryLive = require_Schema$1.effect(ProviderRegistry, require_S
 				cachedProvider,
 				fallbackProvider
 			});
-			return STUB_PROVIDERS.includes(provider) ? fallbackProvider : void 0;
+			return UNBUILT_PROVIDERS.includes(provider) ? fallbackProvider : void 0;
 		}));
-	}, { concurrency: "unbounded" }).pipe(require_Schema$1.map((providers) => orderProviderSnapshots(providers.filter((provider) => provider !== void 0))));
+	}, { concurrency: "unbounded" }).pipe(require_Schema$1.map((providers) => orderProviderSnapshots(providers.filter((provider) => provider !== void 0).map((provider) => withProviderAvailability(provider)))));
 	const providersRef = yield* require_HttpServer.make$3(cachedProviders);
 	const persistProvider = (provider) => writeProviderStatusCache({
 		filePath: cachePathByProvider.get(provider.provider),
@@ -285098,7 +285208,8 @@ const ProviderRegistryLive = require_Schema$1.effect(ProviderRegistry, require_S
 		provider: provider.provider,
 		error
 	})), require_Schema$1.ignore);
-	const upsertProviders = require_Schema$1.fn("upsertProviders")(function* (nextProviders, options) {
+	const upsertProviders = require_Schema$1.fn("upsertProviders")(function* (incomingProviders, options) {
+		const nextProviders = incomingProviders.map((provider) => withProviderAvailability(provider));
 		const [previousProviders, providers] = yield* require_HttpServer.modify(providersRef, (previousProviders) => {
 			const mergedProviders = new Map(previousProviders.map((provider) => [provider.provider, provider]));
 			for (const provider of nextProviders) mergedProviders.set(provider.provider, provider);
@@ -287887,7 +287998,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "e65edd4d1b8a361863a52b171b5e73295d691e11";
+	return "86c71b55bb7a5dfbbad063d6e4c082570759f006";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -300625,21 +300736,24 @@ function processRuntimeReplicationOutboxItem(item, dependencies) {
 //#endregion
 //#region src/runtimeReplication/Services/ActiveHourMeter.ts
 var ActiveHourMeter = class extends require_Schema$1.Service()("forge/runtimeReplication/Services/ActiveHourMeter") {};
-//#endregion
-//#region ../../packages/shared/src/providerExecution.ts
+/** `slug` and `name` are `.min(1).max(512)` on the receiving schema. */
+const FIELD_MAX_LENGTH = 512;
+/** `version` is `.max(128)` on the receiving schema, with no length floor. */
+const VERSION_MAX_LENGTH = 128;
+/** `binaryPath` is `.max(2048)` on the receiving schema, with no length floor. */
+const BINARY_PATH_MAX_LENGTH = 2048;
 /**
-* Canonical provider-readiness gate for starting work.
+* Trim to the receiving schema's maximum, or null.
 *
-* Cloud user VMs can execute through Forge's scoped provider proxy without a
-* provider-local login. In that case the provider reports unauthenticated but
-* its credential provenance is explicitly `proxied`.
+* Neither field has a length floor, so an empty string would be legal — but it
+* is not an answer. A version nobody resolved and a binary nobody found are
+* both null, which is what the control plane stores and what a reader can tell
+* apart from a real value.
 */
-function isServerProviderExecutable(provider) {
-	const hasExecutionAuthority = provider.auth.status !== "unauthenticated" || provider.auth.provenance?.credentialScope === "proxied";
-	return provider.enabled && provider.installed && provider.status === "ready" && hasExecutionAuthority && provider.models.length > 0;
+function cappedText(value, max) {
+	const normalized = value?.trim().slice(0, max);
+	return normalized ? normalized : null;
 }
-/** `slug` and `name` are `.min(1).max(512)` on the receiving schema. */
-const FIELD_MAX_LENGTH = 512;
 function serializeModel(model) {
 	const slug = model.slug.trim().slice(0, FIELD_MAX_LENGTH);
 	const name = model.name.trim().slice(0, FIELD_MAX_LENGTH);
@@ -300653,20 +300767,48 @@ function serializeModel(model) {
 		name
 	};
 }
+/**
+* The availability to publish for one provider.
+*
+* The registry stamps every snapshot before it leaves, so this normally copies.
+* Deriving over a stamped snapshot would lose the one fact only the registry
+* holds — which providers this build cannot run at all — and republish every
+* Unbuilt provider as Not on this Environment. The fallback covers a snapshot
+* that reached the outbox from some other path.
+*
+* Built by spread so a key with no value is ABSENT rather than `undefined`: the
+* receiving object is `.strict()`, `undefined` is not a legal enum member, and
+* the outbox retries the resulting 400 forever.
+*/
+function publishedAvailability(provider) {
+	if (provider.availability === void 0) return deriveProviderAvailability(provider);
+	const reason = provider.unavailableReason;
+	const detail = provider.unavailableDetail;
+	return {
+		availability: provider.availability,
+		...reason === void 0 ? {} : { unavailableReason: reason },
+		...detail === void 0 ? {} : { unavailableDetail: detail }
+	};
+}
+function serializeProvider(provider) {
+	const models = [];
+	for (const model of provider.models) {
+		if (models.length >= 256) break;
+		const serialized = serializeModel(model);
+		if (serialized) models.push(serialized);
+	}
+	return {
+		provider: provider.provider,
+		models,
+		...publishedAvailability(provider),
+		version: cappedText(provider.version, VERSION_MAX_LENGTH),
+		binaryPath: cappedText(provider.auth.provenance?.binaryPath, BINARY_PATH_MAX_LENGTH)
+	};
+}
 function serializeProviderCatalog(providers) {
 	const catalog = [];
 	for (const provider of providers) {
-		if (!isServerProviderExecutable(provider)) continue;
-		const models = [];
-		for (const model of provider.models) {
-			if (models.length >= 256) break;
-			const serialized = serializeModel(model);
-			if (serialized) models.push(serialized);
-		}
-		catalog.push({
-			provider: provider.provider,
-			models
-		});
+		catalog.push(serializeProvider(provider));
 		if (catalog.length >= 16) break;
 	}
 	return catalog;