@cmmd-center/forge 0.13.43 → 0.13.45

package/dist/bin.cjs

@@ -66243,7 +66243,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.43";
+var version$1 = "0.13.45";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -94509,7 +94509,7 @@ const prepareBootstrapWorktree = (input) => require_Schema$1.gen(function* () {
 		projectCwd: bootstrapWorktree.projectCwd
 	};
 });
-const dispatchBootstrapTurnStart = (input, command) => require_Schema$1.gen(function* () {
+const dispatchBootstrapTurnStart$1 = (input, command) => require_Schema$1.gen(function* () {
 	const { orchestrationEngine, git, gitStatusBroadcaster, projectSetupScriptRunner } = input;
 	const bootstrap = command.bootstrap;
 	const { bootstrap: _bootstrap, ...finalTurnStartCommand } = command;
@@ -94659,6 +94659,48 @@ const dispatchBootstrapTurnStart = (input, command) => require_Schema$1.gen(func
 	})), command.threadId);
 });
 //#endregion
+//#region src/orchestration/Services/SpriteTaskHoldReactor.ts
+/**
+* SpriteTaskHoldReactor - keeps a Fly.io Sprite awake while a turn is running.
+*
+* Reacts to provider turn lifecycle events and holds the sprite's run open for
+* the duration of each turn. See `sprite/spriteTaskHold.ts` for the measurements
+* and the ordering rule this depends on.
+*
+* @module SpriteTaskHoldReactor
+*/
+/**
+* SpriteTaskHoldReactor - Service tag for the sprite task hold worker.
+*/
+var SpriteTaskHoldReactor = class extends require_Schema$1.Service()("forge/orchestration/Services/SpriteTaskHoldReactor") {};
+//#endregion
+//#region src/orchestration/bootstrapLaunch.ts
+/**
+* The entry point for launching a thread: a bootstrap turn start, held awake.
+*
+* A launch creates the thread, adds the worktree and starts the setup script before the first
+* provider event exists, so no turn hold covers it. On a sprite with nothing connected that
+* work advances at about 1.7% of wall clock (`sprite/spriteTaskHold.ts`). A person who sends a
+* first message and closes the tab would otherwise wait most of an hour for a one-minute
+* install.
+*
+* Callers import the dispatch from here. `bootstrapDispatch.ts` stays unaware of sprites.
+*/
+/**
+* Runs a launch with the sprite held awake. A launch that fails or is cancelled releases the
+* hold. One that succeeds keeps it: the reactor hands over to the turn's own hold when the turn
+* starts, and the hold's refresh budget ends it if the turn never does. Where no reactor is
+* wired the launch runs unchanged.
+*/
+const withLaunchHold = (threadId, launch) => require_Schema$1.gen(function* () {
+	const reactor = yield* require_Schema$1.serviceOption(SpriteTaskHoldReactor);
+	if (require_Schema$1.isNone(reactor)) return yield* launch;
+	const release = () => reactor.value.releaseLaunch(threadId);
+	return yield* require_Schema$1.uninterruptible(reactor.value.holdLaunch(threadId)).pipe(require_Schema$1.andThen(require_Schema$1.yieldNow), require_Schema$1.andThen(launch), require_Schema$1.onError(release));
+});
+/** `dispatchBootstrapTurnStart` from `bootstrapDispatch.ts`, with the launch held awake. */
+const dispatchBootstrapTurnStart = (input, command) => withLaunchHold(String(command.threadId), dispatchBootstrapTurnStart$1(input, command));
+//#endregion
 //#region src/orchestration/Services/OrchestrationEngine.ts
 /**
 * OrchestrationEngineService - Service tag for orchestration engine access.
@@ -211160,7 +211202,8 @@ async function listCatalog(resolveJwt, scope) {
 			catalogVersion: data.catalogVersion,
 			capabilitySessionId: data.capabilitySessionId,
 			capabilityToken: data.capabilityToken,
-			expiresAt: data.expiresAt
+			expiresAt: data.expiresAt,
+			...data.codewebMcp ? { codewebMcp: data.codewebMcp } : {}
 		};
 	} catch (error) {
 		return {
@@ -211255,7 +211298,8 @@ async function resolveCmmdSidekickToolCatalog(resolveJwt, threadId) {
 	const catalog = await session.getCatalog();
 	return {
 		session,
-		tools: catalog.ok ? catalog.tools : []
+		tools: catalog.ok ? catalog.tools : [],
+		...catalog.ok && catalog.codewebMcp ? { codewebMcp: catalog.codewebMcp } : {}
 	};
 }
 //#endregion
@@ -214883,6 +214927,18 @@ function createComputerMcpServer(computerManager, threadId) {
 */
 const CODEWEB_MCP_SERVER_NAME = "codeweb";
 const CODEWEB_MCP_SERVER_URL = "https://codeweb.cmmd.ai/mcp";
+/**
+* CMMD's grant is the primary control for the CodeWeb injection (ADR-011:
+* CMMD decides, Forge relays, the same pattern as the Sidekick tools). A
+* grant present in the catalog response decides, even when it disagrees with
+* the local setting. Absent grant (CMMD unreachable, auth failure, or an
+* older CMMD without the field, CMMD#4882) falls back to
+* `ServerSettings.codewebMcp` so deployments without the grant channel
+* (local/dev) keep a working switch.
+*/
+function resolveCodewebMcpEnabled(input) {
+	return input.grant ? input.grant.enabled : input.setting;
+}
 //#endregion
 //#region src/cmmdData/cmmdContextMcpServer.ts
 /**
@@ -215760,7 +215816,10 @@ function buildClaudeMcpServers(input) {
 		[GITHUB_MCP_SERVER_NAME]: createGitHubMcpServer(input.runBrokeredGitHubTool, input.threadId, input.serverSettings),
 		...input.computerManager ? { [COMPUTER_MCP_SERVER_NAME]: createComputerMcpServer(input.computerManager, input.threadId) } : {},
 		...input.cmmdSidekickTools ? { "cmmd-sidekick-tools": createCmmdSidekickToolsMcpServer(input.cmmdSidekickTools.session, input.cmmdSidekickTools.tools) } : {},
-		...input.serverSettings.codewebMcp ? { [CODEWEB_MCP_SERVER_NAME]: {
+		...resolveCodewebMcpEnabled({
+			grant: input.codewebMcpGrant,
+			setting: input.serverSettings.codewebMcp
+		}) ? { [CODEWEB_MCP_SERVER_NAME]: {
 			type: "http",
 			url: CODEWEB_MCP_SERVER_URL
 		} } : {}
@@ -215788,18 +215847,11 @@ function createCmmdPatResolver(threadId) {
 		return readCommandAccessTokenForSession(ownerSessionId);
 	};
 }
-/**
-* Fetches CMMD's permitted Sidekick-tool catalog once for this session, via
-* the resolver shared with `CodexAdapter.ts` (`resolveCmmdSidekickToolCatalog`).
-*
-* The MCP server's tool list must be static at construction time, so the
-* catalog is fetched here rather than lazily inside a tool call. A failure
-* (no CMMD session, no permitted tools, upstream error) just means the
-* server is omitted this turn — CMMD remains free to grant a different
-* catalog on the next one.
-*/
 function resolveCmmdSidekickTools(resolveJwt, threadId) {
-	return require_Schema$1.promise(() => resolveCmmdSidekickToolCatalog(resolveJwt, threadId)).pipe(require_Schema$1.map((resolved) => resolved.tools.length > 0 ? resolved : null));
+	return require_Schema$1.promise(() => resolveCmmdSidekickToolCatalog(resolveJwt, threadId)).pipe(require_Schema$1.map((resolved) => ({
+		registration: resolved.tools.length > 0 ? resolved : null,
+		codewebMcpGrant: resolved.codewebMcp
+	})));
 }
 function buildDevServerToolDeps(input) {
 	return {
@@ -217985,7 +218037,7 @@ const makeClaudeAdapter = require_Schema$1.fn("makeClaudeAdapter")(function* (op
 			readThreadAuth: (targetThreadId) => runWithSqlRuntimeContext(readThreadAuthSession(targetThreadId)),
 			resolveJwt: (options) => runWithSqlRuntimeContext(resolveCmmdJwtForSession(options))
 		});
-		const cmmdSidekickTools = yield* resolveCmmdSidekickTools(resolveCmmdSidekickJwtForSession, threadId);
+		const cmmdSidekickResolution = yield* resolveCmmdSidekickTools(resolveCmmdSidekickJwtForSession, threadId);
 		const devServerToolDeps = buildDevServerToolDeps({
 			threadDevRuntime,
 			devTunnel,
@@ -218050,7 +218102,8 @@ const makeClaudeAdapter = require_Schema$1.fn("makeClaudeAdapter")(function* (op
 			computerManager,
 			resolveCmmdPat,
 			devServerToolDeps,
-			cmmdSidekickTools,
+			cmmdSidekickTools: cmmdSidekickResolution.registration,
+			codewebMcpGrant: cmmdSidekickResolution.codewebMcpGrant,
 			runBrokeredGitHubTool,
 			serverSettings
 		}), threadId);
@@ -222859,14 +222912,18 @@ function formatConfigOptionValue(value) {
 /**
 * Builds the `mcpServers` payload for session/new and session/load.
 *
-* CodeWeb (ADR-011) is injected only when the setting is relayed as enabled
-* AND the agent advertised `mcpCapabilities.http` in initialize (the schema
+* CodeWeb (ADR-011) is injected only when CMMD's grant (primary control,
+* CMMD#4882) or, absent a grant, the relayed local setting enables it, AND
+* the agent advertised `mcpCapabilities.http` in initialize (the schema
 * defaults it to false). Sending an http entry to an agent that cannot
 * consume it would at best be dropped, at worst error the session, so both
 * gates must pass; anything else stays an empty payload.
 */
 function buildAcpMcpServers(input) {
-	if (!input.codewebMcpEnabled) return [];
+	if (!resolveCodewebMcpEnabled({
+		grant: input.codewebMcpGrant,
+		setting: input.codewebMcpEnabled
+	})) return [];
 	if (input.agentCapabilities?.mcpCapabilities?.http !== true) return [];
 	return [{
 		type: "http",
@@ -223022,6 +223079,7 @@ const makeAcpSessionRuntime = (options) => require_Schema$1.gen(function* () {
 		let sessionSetupResult;
 		const mcpServers = buildAcpMcpServers({
 			codewebMcpEnabled: options.codewebMcp === true,
+			...options.codewebMcpGrant ? { codewebMcpGrant: options.codewebMcpGrant } : {},
 			agentCapabilities: initializeResult.agentCapabilities
 		});
 		if (options.resumeSessionId) {
@@ -240983,8 +241041,13 @@ var SpriteTaskHoldManager = class {
 	activeTurnIds() {
 		return [...this.#holds.keys()];
 	}
-	async acquire(turnId, threadId = null) {
+	/**
+	* `maxRefreshes` bounds a hold that has no terminal event of its own, such as a launch
+	* whose turn may never start. When the budget is spent the hold releases itself.
+	*/
+	async acquire(turnId, threadId = null, options = {}) {
 		if (this.#holds.has(turnId)) return;
+		let refreshesLeft = options.maxRefreshes ?? Number.POSITIVE_INFINITY;
 		const name = spriteTaskHoldName(this.#config.namePrefix, turnId);
 		const hold = {
 			name,
@@ -241008,6 +241071,11 @@ var SpriteTaskHoldManager = class {
 		if (hold.released || this.#holds.get(turnId) !== hold) return;
 		hold.refresher = this.#timer.setInterval(() => {
 			if (hold.inFlight.size > 0) return;
+			if (refreshesLeft <= 0) {
+				if (this.#holds.get(turnId) === hold) this.release(turnId);
+				return;
+			}
+			refreshesLeft -= 1;
 			const refresh = this.#transport.put(name, 300).catch((cause) => this.#onError(`failed to refresh sprite task hold for turn ${turnId}`, cause));
 			hold.inFlight.add(refresh);
 			refresh.finally(() => hold.inFlight.delete(refresh));
@@ -287071,21 +287139,6 @@ var ProviderRuntimeIngestionService = class extends require_Schema$1.Service()("
 //#region src/orchestration/Services/PlanTaskCreationReactor.ts
 var PlanTaskCreationReactor = class extends require_Schema$1.Service()("forge/orchestration/Services/PlanTaskCreationReactor") {};
 //#endregion
-//#region src/orchestration/Services/SpriteTaskHoldReactor.ts
-/**
-* SpriteTaskHoldReactor - keeps a Fly.io Sprite awake while a turn is running.
-*
-* Reacts to provider turn lifecycle events and holds the sprite's run open for
-* the duration of each turn. See `sprite/spriteTaskHold.ts` for the measurements
-* and the ordering rule this depends on.
-*
-* @module SpriteTaskHoldReactor
-*/
-/**
-* SpriteTaskHoldReactor - Service tag for the sprite task hold worker.
-*/
-var SpriteTaskHoldReactor = class extends require_Schema$1.Service()("forge/orchestration/Services/SpriteTaskHoldReactor") {};
-//#endregion
 //#region src/persistence/Services/ProjectionProjects.ts
 /**
 * ProjectionProjectRepository - Projection repository interface for projects.
@@ -293635,34 +293688,67 @@ const CheckpointReactorLive = require_Schema$1.effect(CheckpointReactor, make$7)
 * it is provider-agnostic: codex, claude and every other adapter emit
 * `turn.started` / `turn.completed` through `ProviderService.streamEvents`.
 */
+/**
+* A launch hold refreshes every 60 s, so this budget is about ten minutes. A launch whose turn
+* never starts, because the provider refused it or the process died first, has no event to
+* release it. The budget is what stops that hold from keeping the sprite billing.
+*/
+const LAUNCH_HOLD_MAX_REFRESHES = 10;
+/** The hold id of a thread's launch. One launch per thread, so the thread names it. */
+const launchHoldId = (threadId) => `launch-${threadId}`;
 const make$6 = require_Schema$1.gen(function* () {
 	const providerService = yield* ProviderService;
 	const manager = makeSpriteTaskHoldManager(process.env, (message, cause) => {
 		require_Schema$1.runFork(require_Schema$1.logWarning(message, { cause: cause instanceof Error ? cause.message : cause }));
 	});
+	const launchCallers = /* @__PURE__ */ new Map();
+	const start = require_Schema$1.fn("start")(function* () {
+		if (manager === null) return;
+		yield* require_Schema$1.forkScoped(require_Path.runForEach(providerService.streamEvents, (event) => {
+			if (event.type === "turn.started") {
+				const turnId = event.turnId;
+				if (turnId === void 0) return require_Schema$1.void_;
+				return require_Schema$1.promise(async () => {
+					await manager.acquire(String(turnId), String(event.threadId));
+					launchCallers.delete(String(event.threadId));
+					await manager.release(launchHoldId(String(event.threadId)));
+				});
+			}
+			if (event.type === "turn.completed") {
+				const turnId = event.turnId;
+				if (turnId === void 0) return require_Schema$1.void_;
+				return require_Schema$1.promise(() => manager.release(String(turnId)));
+			}
+			if (event.type === "turn.aborted") {
+				const turnId = event.turnId;
+				if (turnId === void 0) return require_Schema$1.void_;
+				return require_Schema$1.promise(() => manager.release(String(turnId)));
+			}
+			if (event.type === "session.exited") {
+				launchCallers.delete(String(event.threadId));
+				return require_Schema$1.promise(() => manager.releaseThread(String(event.threadId)));
+			}
+			return require_Schema$1.void_;
+		}));
+	});
+	/** Takes the launch hold for one more caller. The budget bounds a launch that never starts a turn. */
+	const holdLaunch = (threadId) => require_Schema$1.promise(async () => {
+		if (manager === null) return;
+		launchCallers.set(threadId, (launchCallers.get(threadId) ?? 0) + 1);
+		await manager.acquire(launchHoldId(threadId), threadId, { maxRefreshes: LAUNCH_HOLD_MAX_REFRESHES });
+	});
+	/** Lets one caller go. The hold itself is released when the last caller has let go. */
+	const releaseLaunch = (threadId) => require_Schema$1.promise(async () => {
+		if (manager === null) return;
+		const remaining = (launchCallers.get(threadId) ?? 1) - 1;
+		if (remaining > 0) return void launchCallers.set(threadId, remaining);
+		launchCallers.delete(threadId);
+		await manager.release(launchHoldId(threadId));
+	});
 	return {
-		start: require_Schema$1.fn("start")(function* () {
-			if (manager === null) return;
-			yield* require_Schema$1.forkScoped(require_Path.runForEach(providerService.streamEvents, (event) => {
-				if (event.type === "turn.started") {
-					const turnId = event.turnId;
-					if (turnId === void 0) return require_Schema$1.void_;
-					return require_Schema$1.promise(() => manager.acquire(String(turnId), String(event.threadId)));
-				}
-				if (event.type === "turn.completed") {
-					const turnId = event.turnId;
-					if (turnId === void 0) return require_Schema$1.void_;
-					return require_Schema$1.promise(() => manager.release(String(turnId)));
-				}
-				if (event.type === "turn.aborted") {
-					const turnId = event.turnId;
-					if (turnId === void 0) return require_Schema$1.void_;
-					return require_Schema$1.promise(() => manager.release(String(turnId)));
-				}
-				if (event.type === "session.exited") return require_Schema$1.promise(() => manager.releaseThread(String(event.threadId)));
-				return require_Schema$1.void_;
-			}));
-		}),
+		start,
+		holdLaunch,
+		releaseLaunch,
 		releaseAll: require_Schema$1.promise(() => manager === null ? Promise.resolve() : manager.releaseAll())
 	};
 });
@@ -297808,7 +297894,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "f42e124b2bff6bb73499fe42a9e44411a8961e1c";
+	return "8ada8bfccfb8a4b0827961f304821e7b11249865";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;