@cmmd-center/forge 0.9.15 → 0.9.17

package/dist/bin.mjs

@@ -22,7 +22,7 @@ import { createCipheriv, createDecipheriv, createHash, createHmac, createPublicK
 import * as FS$1 from "node:fs";
 import fs, { accessSync, chmodSync, constants, createReadStream, existsSync, mkdirSync, mkdtempSync, promises, readFile, readFileSync, readdir, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as NodeOS from "node:os";
-import $U, { homedir, networkInterfaces, tmpdir } from "node:os";
+import os, { homedir, networkInterfaces, tmpdir } from "node:os";
 import * as Path$1 from "node:path";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -22164,6 +22164,40 @@ const ServerProviderAuth = Struct({
 	accountEmail: optional$4(TrimmedNonEmptyString),
 	provenance: optional$4(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 = 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 = 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 = Literals([
+	"no-connection",
+	"delivery-pending",
+	"reconnect-required"
+]);
 const ServerProviderModel = Struct({
 	slug: TrimmedNonEmptyString,
 	name: TrimmedNonEmptyString,
@@ -22195,6 +22229,9 @@ const ServerProvider = Struct({
 	checkedAt: IsoDateTime,
 	message: optional$4(TrimmedNonEmptyString),
 	models: ArraySchema(ServerProviderModel),
+	availability: optional$4(ProviderAvailability),
+	unavailableReason: optional$4(ProviderUnavailableReason),
+	unavailableDetail: optional$4(ProviderUnavailableDetail),
 	slashCommands: ArraySchema(ServerProviderSlashCommand).pipe(withDecodingDefault(succeed([]))),
 	skills: ArraySchema(ServerProviderSkill).pipe(withDecodingDefault(succeed([])))
 });
@@ -49482,7 +49519,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
 	const min = forceColor || 0;
 	if (env.TERM === "dumb") return min;
 	if (process$1.platform === "win32") {
-		const osRelease = $U.release().split(".");
+		const osRelease = os.release().split(".");
 		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		return 1;
 	}
@@ -51925,7 +51962,7 @@ var require_ProcessDetector = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.processDetector = void 0;
 	const api_1 = (init_esm$1(), __toCommonJS(esm_exports$1));
 	const semconv_1 = require_semconv$1();
-	const os$3 = __require("os");
+	const os$4 = __require("os");
 	/**
 	* ProcessDetector will be used to detect the resources related current process running
 	* and being instrumented from the NodeJS Process module.
@@ -51947,7 +51984,7 @@ var require_ProcessDetector = /* @__PURE__ */ __commonJSMin(((exports) => {
 			};
 			if (process.argv.length > 1) attributes[semconv_1.ATTR_PROCESS_COMMAND] = process.argv[1];
 			try {
-				const userInfo = os$3.userInfo();
+				const userInfo = os$4.userInfo();
 				attributes[semconv_1.ATTR_PROCESS_OWNER] = userInfo.username;
 			} catch (e) {
 				api_1.diag.debug(`error obtaining process owner: ${e}`);
@@ -64870,7 +64907,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.9.15";
+var version$1 = "0.9.17";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -73500,7 +73537,7 @@ var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	var fs$6 = __require("fs");
 	var path$5 = __require("path");
 	var url$1 = __require("url");
-	var os$2 = __require("os");
+	var os$3 = __require("os");
 	var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
 	var vars = process.config && process.config.variables || {};
 	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
@@ -73508,8 +73545,8 @@ var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	var abi = versions.modules;
 	if (versions.deno || process.isBun) abi = "unsupported";
 	var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-	var arch = process.env.npm_config_arch || os$2.arch();
-	var platform = process.env.npm_config_platform || os$2.platform();
+	var arch = process.env.npm_config_arch || os$3.arch();
+	var platform = process.env.npm_config_platform || os$3.platform();
 	var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
 	var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
 	var uv = (versions.uv || "").split(".")[0];
@@ -91167,7 +91204,7 @@ const launchDetached = (launch) => gen(function* () {
 });
 const OpenLive = effect(Open, gen(function* () {
 	const open = yield* tryPromise({
-		try: () => import("./open-D8mGyWmt.mjs"),
+		try: () => import("./open-FIgTDosf.mjs"),
 		catch: (cause) => new OpenError$1({
 			message: "failed to load browser opener",
 			cause
@@ -91964,8 +92001,8 @@ const ProjectionThread = Struct({
 	createdAt: IsoDateTime,
 	updatedAt: IsoDateTime,
 	archivedAt: NullOr(IsoDateTime),
-	settledAt: optional$4(NullOr(IsoDateTime)),
-	settledOverride: optional$4(NullOr(Literals(["settled", "active"]))),
+	settledAt: NullOr(IsoDateTime),
+	settledOverride: NullOr(Literals(["settled", "active"])),
 	latestUserMessageAt: NullOr(IsoDateTime),
 	pendingApprovalCount: NonNegativeInt,
 	pendingUserInputCount: NonNegativeInt,
@@ -92150,16 +92187,23 @@ const FORGE_GIT_COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
 /**
 * Resolve the commit this forge checkout actually booted from, so the
 * heartbeat can report it and CMMD can tell a stale Sprite from a current
-* one. Sprites clone forge ONLY at bootstrap (see the CMMD-side bootstrap
-* script) and nothing else refreshes them, so this value never changes for
-* the life of the process — resolve it once and cache it.
-*
-* `git rev-parse HEAD` run with the process's own cwd (`apps/server`, a
-* subdirectory of the cloned repo) walks up to find `.git` on its own; no
-* `-C` path is needed. Returns `undefined` (never throws) when there is no
-* git checkout to read — local dev run from a tarball, or any environment
-* this simply does not apply to — so the heartbeat body omits the field
-* exactly like an older Forge build that doesn't know about it yet.
+* one. The commit cannot change for the life of the process, so resolve it
+* once and cache it.
+*
+* This comment used to say Sprites clone forge at bootstrap and read their
+* commit from that checkout. They do not. A cloud runtime installs the
+* published `@cmmd-center/forge` tarball and has no `.git` anywhere near it,
+* which is why its descriptor reported no commit at all until the server
+* started baking one into its bundle. See `../environment/buildIdentity.ts`,
+* which calls this only as its last rung.
+*
+* `git rev-parse HEAD` run with the process's own cwd walks up to find `.git`
+* on its own, so no `-C` path is needed. That also means a cwd inside some
+* unrelated repository answers with that repository's HEAD, which is one more
+* reason this is the last rung rather than the first. Returns `undefined`
+* (never throws) when there is no checkout to read, so the heartbeat body
+* omits the field exactly like an older Forge build that does not know about
+* it yet.
 */
 let cached$1 = null;
 async function resolveForgeGitCommit(execImpl = (command, args) => execFileAsync$6(command, [...args], { timeout: 5e3 })) {
@@ -184373,7 +184417,7 @@ var Vce = {
 function Ve() {
 	return Vce;
 }
-var Us = $U.homedir(), lk = $U.tmpdir(), { env: Vc } = process$1, Yce = (e) => {
+var Us = os.homedir(), lk = os.tmpdir(), { env: Vc } = process$1, Yce = (e) => {
 	let t = path.join(Us, "Library");
 	return {
 		data: path.join(t, "Application Support", e),
@@ -194573,12 +194617,12 @@ function qZ(e, t) {
 	}
 	return n;
 }
-var os$1 = "https://code.claude.com/docs/en", kKe = [
+var os$2 = "https://code.claude.com/docs/en", kKe = [
 	{
 		matches: (e) => e.path === "permissions.defaultMode" && e.code === "invalid_value",
 		tip: {
 			suggestion: "Valid modes: \"acceptEdits\" (ask before file changes), \"plan\" (analysis only), \"bypassPermissions\" (auto-accept all), or \"default\" (standard behavior)",
-			docLink: `${os$1}/iam#permission-modes`
+			docLink: `${os$2}/iam#permission-modes`
 		}
 	},
 	{
@@ -194593,7 +194637,7 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path.startsWith("env.") && e.code === "invalid_type",
 		tip: {
 			suggestion: "Environment variables must be strings. Wrap numbers and booleans in quotes. Example: \"DEBUG\": \"true\", \"PORT\": \"3000\"",
-			docLink: `${os$1}/settings#environment-variables`
+			docLink: `${os$2}/settings#environment-variables`
 		}
 	},
 	{
@@ -194604,14 +194648,14 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path.startsWith("hooks.") && e.code === "invalid_key",
 		tip: {
 			suggestion: "Not a recognized hook event. Common events: PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, SessionEnd, Stop. Check spelling and capitalization.",
-			docLink: `${os$1}/hooks`
+			docLink: `${os$2}/hooks`
 		}
 	},
 	{
 		matches: (e) => /\.hooks\.\d+\.command$/.test(e.path) && e.code === "invalid_type" && e.received === "undefined",
 		tip: {
 			suggestion: "Command hooks require `command`. For exec form (no shell), set `command` to the executable and `args` to its arguments: {\"type\": \"command\", \"command\": \"echo\", \"args\": [\"hi\"]}. For shell form, set `command` to the full shell string: {\"type\": \"command\", \"command\": \"echo hi\"}.",
-			docLink: `${os$1}/hooks#exec-form-and-shell-form`
+			docLink: `${os$2}/hooks#exec-form-and-shell-form`
 		}
 	},
 	{
@@ -194626,7 +194670,7 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.code === "unrecognized_keys",
 		tip: {
 			suggestion: "Check for typos or refer to the documentation for valid fields",
-			docLink: `${os$1}/settings`
+			docLink: `${os$2}/settings`
 		}
 	},
 	{
@@ -194641,13 +194685,13 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path === "permissions.additionalDirectories" && e.code === "invalid_type",
 		tip: {
 			suggestion: "Must be an array of directory paths. Example: [\"~/projects\", \"/tmp/workspace\"]. You can also use --add-dir flag or /add-dir command",
-			docLink: `${os$1}/iam#working-directories`
+			docLink: `${os$2}/iam#working-directories`
 		}
 	}
 ], AKe = {
-	permissions: `${os$1}/iam#configuring-permissions`,
-	env: `${os$1}/settings#environment-variables`,
-	hooks: `${os$1}/hooks`
+	permissions: `${os$2}/iam#configuring-permissions`,
+	env: `${os$2}/settings#environment-variables`,
+	hooks: `${os$2}/hooks`
 };
 function GZ(e) {
 	let t = kKe.find((r) => r.matches(e));
@@ -206252,7 +206296,7 @@ function createDevServerMcpServer(deps, threadId) {
 * per provider — this module only adapts descriptor + result shapes.
 *
 * Without it a Claude agent has no brokered push path at all and falls back to
-* raw `git`, which the runtime deliberately blocks via `GIT_ASKPASS=/bin/false`.
+* raw `git`, which has no authenticated remote credentials in the agent runtime.
 *
 * The catalog is filtered through `applyPluginSkillPermissionsToDynamicTools`,
 * exactly as the Codex surface filters its dynamic tools. `settings` is required
@@ -258900,7 +258944,7 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 	var dgram = __require("dgram");
 	var thunky = require_thunky();
 	var events = __require("events");
-	var os = __require("os");
+	var os$1 = __require("os");
 	var noop = function() {};
 	module.exports = function(opts) {
 		if (!opts) opts = {};
@@ -259031,14 +259075,14 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 		return that;
 	};
 	function defaultInterface() {
-		var networks = os.networkInterfaces();
+		var networks = os$1.networkInterfaces();
 		var names = Object.keys(networks);
 		for (var i = 0; i < names.length; i++) {
 			var net = networks[names[i]];
 			for (var j = 0; j < net.length; j++) {
 				var iface = net[j];
 				if (isIPv4(iface.family) && !iface.internal) {
-					if (os.platform() === "darwin" && names[i] === "en0") return iface.address;
+					if (os$1.platform() === "darwin" && names[i] === "en0") return iface.address;
 					return "0.0.0.0";
 				}
 			}
@@ -259046,7 +259090,7 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 		return "127.0.0.1";
 	}
 	function allInterfaces() {
-		var networks = os.networkInterfaces();
+		var networks = os$1.networkInterfaces();
 		var names = Object.keys(networks);
 		var res = [];
 		for (var i = 0; i < names.length; i++) {
@@ -284570,14 +284614,87 @@ const writeProviderStatusCache = (input) => {
 	})));
 };
 //#endregion
-//#region src/provider/Layers/ProviderRegistry.ts
+//#region ../../packages/shared/src/providerExecution.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.
+* 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`.
 */
-const STUB_PROVIDERS = [];
+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
+/**
+* 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.
+*/
+/**
+* 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) => all([
 	codexProvider.getSnapshot,
 	claudeProvider.getSnapshot,
@@ -284614,9 +284731,9 @@ const ProviderRegistryLive = effect(ProviderRegistry, gen(function* () {
 				cachedProvider,
 				fallbackProvider
 			});
-			return STUB_PROVIDERS.includes(provider) ? fallbackProvider : void 0;
+			return UNBUILT_PROVIDERS.includes(provider) ? fallbackProvider : void 0;
 		}));
-	}, { concurrency: "unbounded" }).pipe(map$3((providers) => orderProviderSnapshots(providers.filter((provider) => provider !== void 0)))));
+	}, { concurrency: "unbounded" }).pipe(map$3((providers) => orderProviderSnapshots(providers.filter((provider) => provider !== void 0).map((provider) => withProviderAvailability(provider))))));
 	const persistProvider = (provider) => writeProviderStatusCache({
 		filePath: cachePathByProvider.get(provider.provider),
 		provider
@@ -284624,7 +284741,8 @@ const ProviderRegistryLive = effect(ProviderRegistry, gen(function* () {
 		provider: provider.provider,
 		error
 	})), ignore);
-	const upsertProviders = fn$1("upsertProviders")(function* (nextProviders, options) {
+	const upsertProviders = fn$1("upsertProviders")(function* (incomingProviders, options) {
+		const nextProviders = incomingProviders.map((provider) => withProviderAvailability(provider));
 		const [previousProviders, providers] = yield* modify$3(providersRef, (previousProviders) => {
 			const mergedProviders = new Map(previousProviders.map((provider) => [provider.provider, provider]));
 			for (const provider of nextProviders) mergedProviders.set(provider.provider, provider);
@@ -287328,13 +287446,32 @@ const ObservabilityLive = unwrap(gen(function* () {
 //#region ../../packages/shared/src/buildCommit.ts
 const COMMIT_SHA_PATTERN$1 = /^[0-9a-f]{40}$/i;
 /**
+* Whether a value is a full commit sha.
+*
+* Exported so each surface can keep its own list of env names while sharing one
+* definition of "valid". Surfaces genuinely differ: Railway injects
+* RAILWAY_GIT_COMMIT_SHA into the cloud shell build, while the desktop release
+* workflows pass VITE_SENTRY_COMMIT_SHA. What must not differ is the check.
+*/
+function isFullCommitSha(value) {
+	const candidate = value?.trim();
+	return candidate !== void 0 && candidate !== "" && COMMIT_SHA_PATTERN$1.test(candidate);
+}
+/**
 * Build identity from the environment.
 *
 * `.dockerignore` excludes `.git`, so `git rev-parse HEAD` cannot resolve inside
 * the Railway container — the surface where "which commit is live?" is asked
 * most. The commit therefore has to arrive as env there, with git left as the
-* fallback for surfaces that genuinely are checkouts (a sprite clones forge at
-* bootstrap; desktop and dev run from a repo).
+* fallback for surfaces that genuinely are checkouts (desktop and dev run from
+* a repo).
+*
+* A cloud runtime is neither: it installs the published `@cmmd-center/forge`
+* tarball, so it has no build variables and no `.git`, and both rungs below
+* return nothing there. That is why the server bakes the commit into its bundle
+* at build time and reads that first — see `apps/server/src/environment/
+* buildIdentity.ts`. This comment previously claimed a sprite clones forge at
+* bootstrap; it does not, and believing it cost a diagnosis.
 *
 * `RAILWAY_GIT_COMMIT_SHA` is injected by the platform, which is what lets this
 * work on the cloud shell with no Dockerfile plumbing. `FORGE_BUILD_COMMIT`
@@ -287352,6 +287489,30 @@ function resolveBuildCommitFromEnv(env) {
 	}
 }
 //#endregion
+//#region src/environment/buildIdentity.ts
+/**
+* Which commit this server was built from.
+*
+* @module
+*/
+/**
+* The commit baked into this bundle, if it is a bundle at all.
+*
+* `typeof` rather than a bare reference: running from source there is no such
+* binding, and a bare reference is a ReferenceError that would take the whole
+* environment descriptor down instead of reporting an honest "unknown".
+*/
+function readBakedBuildCommit() {
+	return "86c71b55bb7a5dfbbad063d6e4c082570759f006";
+}
+async function resolveServerBuildCommit(input) {
+	if (isFullCommitSha(input.baked)) return input.baked;
+	const fromEnv = resolveBuildCommitFromEnv(input.env);
+	if (fromEnv !== void 0) return fromEnv;
+	const fromGit = await input.readGitCommit();
+	return isFullCommitSha(fromGit) ? fromGit : void 0;
+}
+//#endregion
 //#region src/environment/Layers/ServerEnvironmentLabel.ts
 function normalizeLabel(value) {
 	const trimmed = value?.trim();
@@ -287499,7 +287660,11 @@ const ServerEnvironmentLive = effect(ServerEnvironment, fn$1("makeServerEnvironm
 	const writeMetadata = (metadata) => fileSystem.writeFileString(serverConfig.environmentMetadataPath, `${JSON.stringify(metadata, null, 2)}\n`);
 	const displayNameOverrideRef = yield* make$47(normalizeDisplayName((yield* readMetadata).displayName ?? null));
 	const posthog = yield* PosthogPublicConfig.asEffect();
-	const buildCommit = resolveBuildCommitFromEnv(process.env) ?? (yield* promise(() => resolveForgeGitCommit()));
+	const buildCommit = yield* promise(() => resolveServerBuildCommit({
+		baked: readBakedBuildCommit(),
+		env: process.env,
+		readGitCommit: resolveForgeGitCommit
+	}));
 	const buildDescriptor = gen(function* () {
 		const displayNameOverride = yield* get$5(displayNameOverrideRef);
 		const os = platformOs();
@@ -296243,6 +296408,71 @@ function selectProviderUsageEnvironment(rawCatalog, ownerUserId) {
 	};
 }
 //#endregion
+//#region src/command/claudeUsageRefreshFailure.ts
+/**
+* Why a Claude usage refresh failed, in words the Usage page can show.
+*
+* CMMD answers a failed refresh with a machine reason (`runtime_not_active`,
+* `credential_changed`, …). The Shell used to collapse every one of them into
+* "Claude usage refresh is unavailable.", so the card could only say the
+* refresh failed, never what to do about it.
+*
+* The mapping is a closed allowlist in both directions: a reason CMMD may add
+* later falls back to the generic code, and the text a client sees is written
+* here, never forwarded from upstream. That keeps a credential or runtime
+* detail in a CMMD error body from reaching the browser.
+*/
+const FAILURE_TEXT = {
+	CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE: "Refresh needs your Environment running.",
+	CLAUDE_USAGE_CREDENTIAL_NOT_READY: "The Claude credential is not applied to your Environment yet.",
+	CLAUDE_USAGE_REFRESH_IN_PROGRESS: "A refresh for this account is already running.",
+	CLAUDE_USAGE_PROBE_FAILED: "Your Environment could not read Claude usage.",
+	CLAUDE_USAGE_RECONNECT_REQUIRED: "Reconnect this Claude account to refresh usage.",
+	CLAUDE_USAGE_ACCOUNT_NOT_FOUND: "This Claude account is no longer connected.",
+	CLAUDE_USAGE_REFRESH_UNAVAILABLE: "Claude usage refresh is unavailable."
+};
+/** Verbatim from CMMD `personal-claude-usage.ts` and `provider-usage-service.ts`. */
+const CODE_BY_UPSTREAM_REASON = {
+	runtime_not_active: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	claude_native_delivery_disabled: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	runtime_identity_mismatch: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	credential_generation_not_applied: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	credential_generation_unavailable: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	credential_changed: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	refresh_in_progress: "CLAUDE_USAGE_REFRESH_IN_PROGRESS",
+	usage_probe_failed: "CLAUDE_USAGE_PROBE_FAILED",
+	usage_receipt_invalid: "CLAUDE_USAGE_PROBE_FAILED",
+	usage_output_invalid: "CLAUDE_USAGE_PROBE_FAILED"
+};
+function failure(code, status) {
+	return {
+		status,
+		body: {
+			error: FAILURE_TEXT[code],
+			code
+		}
+	};
+}
+/**
+* CMMD sends the reason as `{ "error": "<reason>" }`. Anything else, including
+* a longer sentence that happens to start with an allowlisted word, is treated
+* as unknown.
+*/
+function readAllowlistedReasonCode(body) {
+	if (body === null || typeof body !== "object") return null;
+	const reason = body.error;
+	if (typeof reason !== "string") return null;
+	return Object.hasOwn(CODE_BY_UPSTREAM_REASON, reason) ? CODE_BY_UPSTREAM_REASON[reason] ?? null : null;
+}
+function describeClaudeUsageRefreshFailure(error) {
+	if (!(error instanceof CmmdProxyRequestError)) return failure("CLAUDE_USAGE_REFRESH_UNAVAILABLE", 502);
+	if (error.status === 409) return failure("CLAUDE_USAGE_RECONNECT_REQUIRED", 409);
+	if (error.status === 404) return failure("CLAUDE_USAGE_ACCOUNT_NOT_FOUND", 404);
+	const reasonCode = readAllowlistedReasonCode(error.body);
+	if (reasonCode !== null) return failure(reasonCode, 503);
+	return failure("CLAUDE_USAGE_REFRESH_UNAVAILABLE", error.status === 503 ? 503 : 502);
+}
+//#endregion
 //#region src/command/wsToken.ts
 /**
 * Build the WS token response given an optional PAT and the configured CMMD
@@ -297979,10 +298209,8 @@ function resolveProviderUsageOwnerUserId(session) {
 	return Number.isSafeInteger(userId) && userId > 0 ? userId : null;
 }
 function buildClaudeUsageRefreshErrorResponse(error) {
-	return jsonUnsafe({
-		error: "Claude usage refresh is unavailable.",
-		code: "CLAUDE_USAGE_REFRESH_UNAVAILABLE"
-	}, { status: error instanceof CmmdProxyRequestError && error.status === 503 ? 503 : 502 });
+	const failure = describeClaudeUsageRefreshFailure(error);
+	return jsonUnsafe(failure.body, { status: failure.status });
 }
 function makeRefreshProviderUsageHandler(dependencies = {}) {
 	return gen(function* () {
@@ -299937,21 +300165,24 @@ function processRuntimeReplicationOutboxItem(item, dependencies) {
 //#endregion
 //#region src/runtimeReplication/Services/ActiveHourMeter.ts
 var ActiveHourMeter = class extends Service$1()("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);
@@ -299965,20 +300196,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;
@@ -310426,7 +310685,7 @@ const connectLoginCommand = make$32("login", {
 			})).json();
 		},
 		openBrowser: async (url) => {
-			const open = (await import("./open-D8mGyWmt.mjs")).default;
+			const open = (await import("./open-FIgTDosf.mjs")).default;
 			await open(url);
 			return true;
 		},