@p4code/cli 0.2.23 → 0.2.25

package/dist/bin.mjs

@@ -238,7 +238,7 @@ const make$90 = () => {
 const layer$81 = Layer.sync(NetService, make$90);
 //#endregion
 //#region package.json
-var version = "0.2.23";
+var version = "0.2.25";
 //#endregion
 //#region src/config.ts
 /**
@@ -42880,8 +42880,32 @@ const resolveClaudeHomePath = Effect.fn("resolveClaudeHomePath")(function* (conf
 	const homePath = config.homePath.trim();
 	return path.resolve(homePath.length > 0 ? expandHomePath$3(homePath) : NodeOS.homedir());
 });
+/**
+* The macOS login keychain stores the CLI's OAuth credentials under the account
+* name in `USER`. A server started outside a login shell — a desktop app
+* launched from Finder, a launchd job — can hand the child an environment
+* without it, and the CLI then reports no subscription at all rather than
+* failing: `/usage` quietly answers with the session cost report instead of the
+* account's limits. Filling the name back in keeps the lookup working.
+*/
+function withProcessUserName(env) {
+	if (env.USER?.trim() && env.LOGNAME?.trim()) return env;
+	const username = (() => {
+		try {
+			return NodeOS.userInfo().username;
+		} catch {
+			return "";
+		}
+	})();
+	if (username.length === 0) return env;
+	return {
+		...env,
+		...env.USER?.trim() ? {} : { USER: username },
+		...env.LOGNAME?.trim() ? {} : { LOGNAME: username }
+	};
+}
 const makeClaudeEnvironment = Effect.fn("makeClaudeEnvironment")(function* (config, baseEnv) {
-	const resolvedBaseEnv = baseEnv ?? process.env;
+	const resolvedBaseEnv = withProcessUserName(baseEnv ?? process.env);
 	if (config.homePath.trim().length === 0) return resolvedBaseEnv;
 	const resolvedHomePath = yield* resolveClaudeHomePath(config);
 	return {
@@ -66107,7 +66131,7 @@ const makePendingClaudeProvider = (claudeSettings) => Effect.gen(function* () {
 */
 const CLAUDE_TIMEOUT_MS = 18e4;
 /** The usage report is a local lookup, so it should return in seconds, not minutes. */
-const USAGE_REPORT_TIMEOUT_MS = 6e4;
+const USAGE_REPORT_TIMEOUT_MS$1 = 6e4;
 /**
 * Schema for the wrapper JSON returned by `claude -p --output-format json`.
 * We only care about `structured_output`.
@@ -66118,6 +66142,16 @@ const ClaudeOutputEnvelope = Schema$1.Struct({ structured_output: Schema$1.Unkno
 * CLI-local command, so this costs no turn and no tokens.
 */
 const ClaudeResultEnvelope = Schema$1.Struct({ result: Schema$1.String });
+const USAGE_LIMIT_LINE = /^.+:\s+\d+(?:\.\d+)?%\s+used/mu;
+/**
+* When the CLI cannot resolve the account behind its config directory it does
+* not fail: it prints the session's own cost summary — all zeroes for a
+* one-shot run — in place of the account's limits. Only a report that carries a
+* limit line is the report that was asked for.
+*/
+function isClaudeUsageReport(report) {
+	return USAGE_LIMIT_LINE.test(report);
+}
 const encodeJsonString$2 = Schema$1.encodeEffect(Schema$1.UnknownFromJsonString);
 const decodeClaudeOutputEnvelope = Schema$1.decodeEffect(Schema$1.fromJsonString(ClaudeOutputEnvelope));
 const decodeClaudeResultEnvelope = Schema$1.decodeEffect(Schema$1.fromJsonString(ClaudeResultEnvelope));
@@ -66305,18 +66339,23 @@ const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(function*
 					});
 				}
 				return stdout;
-			})().pipe(Effect.scoped, Effect.timeoutOption(USAGE_REPORT_TIMEOUT_MS), Effect.flatMap(Option.match({
+			})().pipe(Effect.scoped, Effect.timeoutOption(USAGE_REPORT_TIMEOUT_MS$1), Effect.flatMap(Option.match({
 				onNone: () => Effect.fail(new TextGenerationError({
 					operation,
 					detail: "Claude CLI request timed out."
 				})),
 				onSome: (value) => Effect.succeed(value)
 			})));
-			return { report: (yield* decodeClaudeResultEnvelope(rawStdout).pipe(Effect.catchTags({ SchemaError: (cause) => Effect.fail(new TextGenerationError({
+			const report = (yield* decodeClaudeResultEnvelope(rawStdout).pipe(Effect.catchTags({ SchemaError: (cause) => Effect.fail(new TextGenerationError({
 				operation,
 				detail: "Claude CLI returned unexpected output format.",
 				cause
-			})) }))).result.trim() };
+			})) }))).result.trim();
+			if (!isClaudeUsageReport(report)) return yield* new TextGenerationError({
+				operation,
+				detail: "Claude CLI answered with its session cost summary instead of the account report. That means it could not read the subscription behind its config directory - run `claude /login` for this instance's CLAUDE_CONFIG_DIR and try again."
+			});
+			return { report };
 		})
 	};
 });
@@ -69588,529 +69627,6 @@ const ClaudeDriver = {
 		};
 	})
 };
-const resolveCodexLaunchArgs = (launchArgs, environment = process.env) => environment["P4CODE_CODEX_LAUNCH_ARGS"]?.trim() || launchArgs?.trim() || "";
-const codexLaunchArgv = (launchArgs) => tokenizeCliArgs(launchArgs);
-const codexAppServerArgs = (launchArgs) => ["app-server", ...codexLaunchArgv(launchArgs)];
-const codexExecLaunchArgs = (launchArgs) => {
-	const args = codexLaunchArgv(launchArgs);
-	const execArgs = [];
-	for (let index = 0; index < args.length; index++) {
-		const arg = args[index];
-		if (arg === void 0) continue;
-		if (arg === "--strict-config" || arg.startsWith("--config=") || arg.startsWith("-c=")) execArgs.push(arg);
-		else if (arg === "--config" || arg === "-c" || arg === "--enable" || arg === "--disable") {
-			const value = args[index + 1];
-			if (value !== void 0 && !value.startsWith("-")) {
-				execArgs.push(arg, value);
-				index++;
-			}
-		} else if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) execArgs.push(arg);
-	}
-	return execArgs;
-};
-const codexSessionAppServerArgs = (appServerArgs, launchArgs) => {
-	const launchAppServerArgs = codexAppServerArgs(launchArgs);
-	return appServerArgs ? [...launchAppServerArgs, ...appServerArgs] : launchAppServerArgs;
-};
-//#endregion
-//#region src/codexModelOptions.ts
-function getCodexServiceTierOptionValue(modelSelection) {
-	return getModelSelectionStringOptionValue(modelSelection, "serviceTier") ?? (getModelSelectionBooleanOptionValue(modelSelection, "fastMode") === true ? "fast" : void 0);
-}
-//#endregion
-//#region src/textGeneration/CodexTextGeneration.ts
-const CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT = "low";
-const CODEX_TIMEOUT_MS = 18e4;
-const encodeJsonString$1 = Schema$1.encodeEffect(Schema$1.UnknownFromJsonString);
-/**
-* Build a Codex text-generation closure bound to a specific `CodexSettings`
-* payload. See `makeCodexAdapter` for the overall per-instance rationale.
-*/
-const makeCodexTextGeneration = Effect.fn("makeCodexTextGeneration")(function* (codexConfig, environment) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const serverConfig = yield* Effect.service(ServerConfig$1);
-	const resolvedEnvironment = environment ?? process.env;
-	const readStreamAsString = (operation, stream) => stream.pipe(Stream.decodeText(), Stream.runFold(() => "", (acc, chunk) => acc + chunk), Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to collect process output")));
-	const writeTempFile = (operation, prefix, content) => fileSystem.makeTempFileScoped({ prefix: `p4code-${prefix}-${process.pid}-` }).pipe(Effect.tap((filePath) => fileSystem.writeFileString(filePath, content)), Effect.mapError((cause) => new TextGenerationError({
-		operation,
-		detail: `Failed to write temp file`,
-		cause
-	})));
-	const safeUnlink = (filePath) => fileSystem.remove(filePath).pipe(Effect.catch(() => Effect.void));
-	const encodeJsonForOperation = (operation, value) => encodeJsonString$1(value).pipe(Effect.mapError((cause) => new TextGenerationError({
-		operation,
-		detail: "Failed to encode structured output schema.",
-		cause
-	})));
-	const materializeImageAttachments = Effect.fn("materializeImageAttachments")(function* (_operation, attachments) {
-		if (!attachments || attachments.length === 0) return { imagePaths: [] };
-		const imagePaths = [];
-		for (const attachment of attachments) {
-			if (attachment.type !== "image") continue;
-			const resolvedPath = resolveAttachmentPath({
-				attachmentsDir: serverConfig.attachmentsDir,
-				attachment
-			});
-			if (!resolvedPath || !path.isAbsolute(resolvedPath)) continue;
-			const fileInfo = yield* fileSystem.stat(resolvedPath).pipe(Effect.orElseSucceed(() => null));
-			if (!fileInfo || fileInfo.type !== "File") continue;
-			imagePaths.push(resolvedPath);
-		}
-		return { imagePaths };
-	});
-	const runCodexJson = Effect.fn("runCodexJson")(function* ({ operation, cwd, prompt, outputSchemaJson, imagePaths = [], cleanupPaths = [], modelSelection }) {
-		const schemaJson = yield* encodeJsonForOperation(operation, toJsonSchemaObject(outputSchemaJson));
-		const schemaPath = yield* writeTempFile(operation, "codex-schema", schemaJson);
-		const outputPath = yield* writeTempFile(operation, "codex-output", "");
-		const runCodexCommand = Effect.fn("runCodexJson.runCodexCommand")(function* () {
-			const launchArgs = resolveCodexLaunchArgs(codexConfig.launchArgs, resolvedEnvironment);
-			const reasoningEffort = getModelSelectionStringOptionValue(modelSelection, "reasoningEffort") ?? CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT;
-			const serviceTier = getCodexServiceTierOptionValue(modelSelection);
-			const spawnCommand = yield* resolveSpawnCommand(codexConfig.binaryPath || "codex", [
-				"exec",
-				...codexExecLaunchArgs(launchArgs),
-				"--ephemeral",
-				"--skip-git-repo-check",
-				"-s",
-				"read-only",
-				"--model",
-				modelSelection.model,
-				"--config",
-				`model_reasoning_effort="${reasoningEffort}"`,
-				...serviceTier ? ["--config", `service_tier="${serviceTier}"`] : [],
-				"--output-schema",
-				schemaPath,
-				"--output-last-message",
-				outputPath,
-				...imagePaths.flatMap((imagePath) => ["--image", imagePath]),
-				"-"
-			], { env: resolvedEnvironment });
-			const command = ChildProcess.make(spawnCommand.command, spawnCommand.args, {
-				env: {
-					...resolvedEnvironment,
-					...codexConfig.homePath ? { CODEX_HOME: expandHomePath$3(codexConfig.homePath) } : {}
-				},
-				cwd,
-				shell: spawnCommand.shell,
-				stdin: { stream: Stream.encodeText(Stream.make(prompt)) }
-			});
-			const child = yield* commandSpawner.spawn(command).pipe(Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to spawn Codex CLI process")));
-			const [stdout, stderr, exitCode] = yield* Effect.all([
-				readStreamAsString(operation, child.stdout),
-				readStreamAsString(operation, child.stderr),
-				child.exitCode.pipe(Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to read Codex CLI exit code")))
-			], { concurrency: "unbounded" });
-			if (exitCode !== 0) {
-				const stderrDetail = stderr.trim();
-				const stdoutDetail = stdout.trim();
-				const detail = stderrDetail.length > 0 ? stderrDetail : stdoutDetail;
-				return yield* new TextGenerationError({
-					operation,
-					detail: detail.length > 0 ? `Codex CLI command failed: ${detail}` : `Codex CLI command failed with code ${exitCode}.`
-				});
-			}
-		});
-		const cleanup = Effect.all([
-			schemaPath,
-			outputPath,
-			...cleanupPaths
-		].map((filePath) => safeUnlink(filePath)), { concurrency: "unbounded" }).pipe(Effect.asVoid);
-		return yield* Effect.gen(function* () {
-			yield* runCodexCommand().pipe(Effect.scoped, Effect.timeoutOption(CODEX_TIMEOUT_MS), Effect.flatMap(Option.match({
-				onNone: () => Effect.fail(new TextGenerationError({
-					operation,
-					detail: "Codex CLI request timed out."
-				})),
-				onSome: () => Effect.void
-			})));
-			const decodeOutput = Schema$1.decodeEffect(Schema$1.fromJsonString(outputSchemaJson));
-			return yield* fileSystem.readFileString(outputPath).pipe(Effect.mapError((cause) => new TextGenerationError({
-				operation,
-				detail: "Failed to read Codex output file.",
-				cause
-			})), Effect.flatMap(decodeOutput), Effect.catchTags({ SchemaError: (cause) => Effect.fail(new TextGenerationError({
-				operation,
-				detail: "Codex returned invalid structured output.",
-				cause
-			})) }));
-		}).pipe(Effect.ensuring(cleanup));
-	});
-	return {
-		generateCommitMessage: Effect.fn("CodexTextGeneration.generateCommitMessage")(function* (input) {
-			const { prompt, outputSchema } = buildCommitMessagePrompt({
-				branch: input.branch,
-				stagedSummary: input.stagedSummary,
-				stagedPatch: input.stagedPatch,
-				includeBranch: input.includeBranch === true,
-				policy: input.policy
-			});
-			const generated = yield* runCodexJson({
-				operation: "generateCommitMessage",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			});
-			return {
-				subject: sanitizeCommitSubject(generated.subject),
-				body: generated.body.trim(),
-				..."branch" in generated && typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
-			};
-		}),
-		generatePrContent: Effect.fn("CodexTextGeneration.generatePrContent")(function* (input) {
-			const { prompt, outputSchema } = buildPrContentPrompt({
-				baseBranch: input.baseBranch,
-				headBranch: input.headBranch,
-				commitSummary: input.commitSummary,
-				diffSummary: input.diffSummary,
-				diffPatch: input.diffPatch,
-				policy: input.policy,
-				changeRequestTemplate: input.changeRequestTemplate
-			});
-			const generated = yield* runCodexJson({
-				operation: "generatePrContent",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			});
-			return {
-				title: sanitizePrTitle(generated.title),
-				body: generated.body.trim()
-			};
-		}),
-		generateBranchName: Effect.fn("CodexTextGeneration.generateBranchName")(function* (input) {
-			const { imagePaths } = yield* materializeImageAttachments("generateBranchName", input.attachments);
-			const { prompt, outputSchema } = buildBranchNamePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			return { branch: sanitizeBranchFragment((yield* runCodexJson({
-				operation: "generateBranchName",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				imagePaths,
-				modelSelection: input.modelSelection
-			})).branch) };
-		}),
-		generateThreadTitle: Effect.fn("CodexTextGeneration.generateThreadTitle")(function* (input) {
-			const { imagePaths } = yield* materializeImageAttachments("generateThreadTitle", input.attachments);
-			const { prompt, outputSchema } = buildThreadTitlePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			return { title: sanitizeThreadTitle((yield* runCodexJson({
-				operation: "generateThreadTitle",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				imagePaths,
-				modelSelection: input.modelSelection
-			})).title) };
-		})
-	};
-});
-//#endregion
-//#region ../../packages/effect-codex-app-server/src/errors.ts
-const CodexAppServerRequestOperation = Schema$1.Literals([
-	"decode-payload",
-	"encode-payload",
-	"handle-request",
-	"receive-response"
-]);
-const CodexAppServerSchemaIssueKind = Schema$1.Literals([
-	"Filter",
-	"Encoding",
-	"Pointer",
-	"Composite",
-	"AnyOf",
-	"InvalidType",
-	"InvalidValue",
-	"MissingKey",
-	"UnexpectedKey",
-	"Forbidden",
-	"OneOf"
-]);
-const schemaIssueDiagnostics$1 = (root) => {
-	let issueCount = 0;
-	let maximumPathDepth = 0;
-	const issueKinds = /* @__PURE__ */ new Set();
-	const visit = (issue, pathDepth) => {
-		issueCount += 1;
-		issueKinds.add(issue._tag);
-		maximumPathDepth = Math.max(maximumPathDepth, pathDepth);
-		switch (issue._tag) {
-			case "Filter":
-			case "Encoding":
-				visit(issue.issue, pathDepth);
-				break;
-			case "Pointer":
-				visit(issue.issue, pathDepth + issue.path.length);
-				break;
-			case "Composite":
-			case "AnyOf":
-				for (const child of issue.issues) visit(child, pathDepth);
-				break;
-		}
-	};
-	visit(root, 0);
-	return {
-		issueCount,
-		issueKinds: [...issueKinds],
-		maximumPathDepth
-	};
-};
-const CodexAppServerPayloadKind = Schema$1.Literals([
-	"null",
-	"array",
-	"string",
-	"number",
-	"boolean",
-	"bigint",
-	"object",
-	"symbol",
-	"function",
-	"undefined"
-]);
-const payloadKind = (payload) => {
-	if (payload === null) return "null";
-	if (Array.isArray(payload)) return "array";
-	return typeof payload;
-};
-const protocolMessageFields = [
-	"id",
-	"method",
-	"params",
-	"result",
-	"error"
-];
-const CodexAppServerProtocolMessageField = Schema$1.Literals(protocolMessageFields);
-const CodexAppServerProtocolParseOperation = Schema$1.Literals([
-	"encode-wire-message",
-	"decode-wire-message",
-	"route-wire-message",
-	"decode-notification-payload",
-	"decode-request-payload",
-	"decode-response-payload"
-]);
-const CodexAppServerTransportOperation = Schema$1.Literals(["read-input-stream", "read-process-exit-status"]);
-const CodexAppServerIdentifierPurpose = Schema$1.Literals([
-	"provider-event",
-	"command-approval-request",
-	"file-change-approval-request",
-	"user-input-request"
-]);
-var CodexAppServerSpawnError = class extends Schema$1.TaggedErrorClass()("CodexAppServerSpawnError", {
-	command: Schema$1.optional(Schema$1.String),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return this.command ? `Failed to spawn Codex App Server process for command: ${this.command}` : "Failed to spawn Codex App Server process";
-	}
-};
-var CodexAppServerProcessExitedError = class extends Schema$1.TaggedErrorClass()("CodexAppServerProcessExitedError", {
-	code: Schema$1.optional(Schema$1.Number),
-	pid: Schema$1.optionalKey(Schema$1.Int),
-	cause: Schema$1.optional(Schema$1.Defect())
-}) {
-	get message() {
-		return this.code === void 0 ? "Codex App Server process exited" : `Codex App Server process exited with code ${this.code}`;
-	}
-};
-var CodexAppServerProtocolParseError = class CodexAppServerProtocolParseError extends Schema$1.TaggedErrorClass()("CodexAppServerProtocolParseError", {
-	operation: CodexAppServerProtocolParseOperation,
-	method: Schema$1.optionalKey(Schema$1.String),
-	requestId: Schema$1.optionalKey(Schema$1.String),
-	payloadKind: Schema$1.optionalKey(CodexAppServerPayloadKind),
-	presentFields: Schema$1.optionalKey(Schema$1.Array(CodexAppServerProtocolMessageField)),
-	issueCount: Schema$1.optionalKey(Schema$1.Number),
-	issueKinds: Schema$1.optionalKey(Schema$1.Array(CodexAppServerSchemaIssueKind)),
-	maximumPathDepth: Schema$1.optionalKey(Schema$1.Number),
-	cause: Schema$1.optional(Schema$1.Defect())
-}) {
-	get message() {
-		const method = this.method === void 0 ? "" : ` for method '${this.method}'`;
-		return `Codex App Server protocol operation '${this.operation}' failed${method}.`;
-	}
-	static fromSchemaError(operation, cause, context = {}) {
-		return new CodexAppServerProtocolParseError({
-			operation,
-			...context,
-			...schemaIssueDiagnostics$1(cause.issue),
-			cause
-		});
-	}
-	static fromRequestError(operation, method, cause) {
-		return new CodexAppServerProtocolParseError({
-			operation,
-			method,
-			...cause.issueCount === void 0 ? {} : { issueCount: cause.issueCount },
-			...cause.issueKinds === void 0 ? {} : { issueKinds: cause.issueKinds },
-			...cause.maximumPathDepth === void 0 ? {} : { maximumPathDepth: cause.maximumPathDepth },
-			cause
-		});
-	}
-	static fromUnroutableMessage(message) {
-		const diagnostics = { payloadKind: payloadKind(message) };
-		if (typeof message !== "object" || message === null || Array.isArray(message)) return new CodexAppServerProtocolParseError({
-			operation: "route-wire-message",
-			...diagnostics
-		});
-		const presentFields = protocolMessageFields.filter((field) => field in message);
-		const method = "method" in message && typeof message.method === "string" ? message.method : void 0;
-		const requestId = "id" in message && (typeof message.id === "string" || typeof message.id === "number") ? String(message.id) : void 0;
-		return new CodexAppServerProtocolParseError({
-			operation: "route-wire-message",
-			...diagnostics,
-			presentFields,
-			...method === void 0 ? {} : { method },
-			...requestId === void 0 ? {} : { requestId }
-		});
-	}
-};
-var CodexAppServerTransportError = class extends Schema$1.TaggedErrorClass()("CodexAppServerTransportError", {
-	operation: CodexAppServerTransportOperation,
-	pid: Schema$1.optionalKey(Schema$1.Int),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Codex App Server transport operation '${this.operation}' failed.`;
-	}
-};
-var CodexAppServerIdentifierGenerationError = class extends Schema$1.TaggedErrorClass()("CodexAppServerIdentifierGenerationError", {
-	purpose: CodexAppServerIdentifierPurpose,
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to generate Codex App Server identifier for ${this.purpose}.`;
-	}
-};
-var CodexAppServerInputStreamEndedError = class extends Schema$1.TaggedErrorClass()("CodexAppServerInputStreamEndedError", {}) {
-	get message() {
-		return "Codex App Server input stream ended.";
-	}
-};
-var CodexAppServerRequestError = class CodexAppServerRequestError extends Schema$1.TaggedErrorClass()("CodexAppServerRequestError", {
-	code: Schema$1.Number,
-	errorMessage: Schema$1.String,
-	data: Schema$1.optional(Schema$1.Unknown),
-	method: Schema$1.optionalKey(Schema$1.String),
-	requestId: Schema$1.optionalKey(Schema$1.String),
-	operation: Schema$1.optionalKey(CodexAppServerRequestOperation),
-	issueCount: Schema$1.optionalKey(Schema$1.Number),
-	issueKinds: Schema$1.optionalKey(Schema$1.Array(CodexAppServerSchemaIssueKind)),
-	maximumPathDepth: Schema$1.optionalKey(Schema$1.Number),
-	payloadKind: Schema$1.optionalKey(CodexAppServerPayloadKind),
-	cause: Schema$1.optionalKey(Schema$1.Defect())
-}) {
-	get message() {
-		return this.errorMessage;
-	}
-	static fromProtocolError(error, method, requestId) {
-		return new CodexAppServerRequestError({
-			code: error.code,
-			errorMessage: error.message,
-			...error.data !== void 0 ? { data: error.data } : {},
-			method,
-			requestId,
-			operation: "receive-response",
-			cause: error
-		});
-	}
-	static fromAppServerError(error, method) {
-		if (error._tag === "CodexAppServerRequestError") return error;
-		return CodexAppServerRequestError.internalError(`Codex App Server request handler failed for method '${method}'`, void 0, {
-			method,
-			operation: "handle-request",
-			cause: error
-		});
-	}
-	static parseError(message = "Parse error", data) {
-		return new CodexAppServerRequestError({
-			code: -32700,
-			errorMessage: message,
-			...data !== void 0 ? { data } : {}
-		});
-	}
-	static invalidRequest(message = "Invalid request", data) {
-		return new CodexAppServerRequestError({
-			code: -32600,
-			errorMessage: message,
-			...data !== void 0 ? { data } : {}
-		});
-	}
-	static methodNotFound(method) {
-		return new CodexAppServerRequestError({
-			code: -32601,
-			errorMessage: `Method not found: ${method}`
-		});
-	}
-	static invalidParams(message = "Invalid params", data, diagnostics = {}) {
-		return new CodexAppServerRequestError({
-			code: -32602,
-			errorMessage: message,
-			...data !== void 0 ? { data } : {},
-			...diagnostics
-		});
-	}
-	static invalidPayload(method, operation, cause) {
-		const diagnostics = schemaIssueDiagnostics$1(cause.issue);
-		return new CodexAppServerRequestError({
-			code: -32602,
-			errorMessage: `Invalid payload for method '${method}' during '${operation}'`,
-			data: diagnostics,
-			method,
-			operation,
-			...diagnostics,
-			cause
-		});
-	}
-	static unexpectedPayload(method, operation, payload) {
-		const diagnostics = { payloadKind: payloadKind(payload) };
-		return new CodexAppServerRequestError({
-			code: -32602,
-			errorMessage: `Method '${method}' does not accept a payload during '${operation}'`,
-			data: diagnostics,
-			method,
-			operation,
-			...diagnostics
-		});
-	}
-	static internalError(message = "Internal error", data, diagnostics = {}) {
-		return new CodexAppServerRequestError({
-			code: -32603,
-			errorMessage: message,
-			...data !== void 0 ? { data } : {},
-			...diagnostics
-		});
-	}
-	static overloaded(message = "Server overloaded; retry later.", data) {
-		return new CodexAppServerRequestError({
-			code: -32001,
-			errorMessage: message,
-			...data !== void 0 ? { data } : {}
-		});
-	}
-	toProtocolError() {
-		return {
-			code: this.code,
-			message: this.errorMessage,
-			...this.data !== void 0 ? { data: this.data } : {}
-		};
-	}
-};
-const CodexAppServerError = Schema$1.Union([
-	CodexAppServerRequestError,
-	CodexAppServerSpawnError,
-	CodexAppServerProcessExitedError,
-	CodexAppServerProtocolParseError,
-	CodexAppServerTransportError,
-	CodexAppServerIdentifierGenerationError,
-	CodexAppServerInputStreamEndedError
-]);
 //#endregion
 //#region ../../packages/effect-codex-app-server/src/_generated/schema.gen.ts
 const ApplyPatchApprovalParams__FileChange = Schema$1.Union([
@@ -87573,80 +87089,303 @@ const SERVER_NOTIFICATION_PARAMS = {
 	"account/login/completed": V2AccountLoginCompletedNotification
 };
 //#endregion
-//#region src/provider/Layers/codexMcpArgs.ts
-/** Codex's own name for the token variable of p4code's built-in server. */
-const CODEX_P4CODE_BEARER_TOKEN_ENV_VAR = "P4_MCP_BEARER_TOKEN";
-/** Prefix for the per-server variables the registered servers get. */
-const BEARER_TOKEN_ENV_VAR_PREFIX = "P4_MCP_BEARER_TOKEN_";
-/** TOML bare keys; anything else has to be quoted inside the dotted path. */
-const BARE_KEY = /^[A-Za-z0-9_-]+$/;
-const AUTHORIZATION_HEADER = "authorization";
-const BEARER_PREFIX = /^Bearer\s+/;
-const configKey = (name, field) => `mcp_servers.${BARE_KEY.test(name) ? name : JSON.stringify(name)}.${field}`;
-/**
-* A variable name derived from the server's, uniquely.
-*
-* Uppercased with every character a shell would not accept replaced, which can
-* collide (`a.b` and `a-b`), so the sanitized name is the prefix and the index
-* keeps it unique. The index is stable within one call, which is all that is
-* needed: the variable and the reference to it are emitted together.
-*/
-const bearerTokenEnvVar = (name, index) => `${BEARER_TOKEN_ENV_VAR_PREFIX}${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_${index}`;
-/**
-* @param resolved - Servers keyed by name, as the registry resolved them.
-* @param exclude - Names p4code declares itself. A registration cannot displace
-*   the built-in `p4-code` server, whose per-thread credential is the only
-*   thing that makes `task_current` and the thread tools work.
-*/
-const toCodexMcpConfig = (resolved, exclude = /* @__PURE__ */ new Set()) => {
-	const args = [];
-	const env = {};
-	const skipped = [];
-	const push = (name, field, value) => {
-		args.push("-c", `${configKey(name, field)}=${value}`);
-	};
-	let index = 0;
-	for (const [name, server] of Object.entries(resolved)) {
-		if (exclude.has(name)) continue;
-		if (server.type === "stdio") {
-			push(name, "command", JSON.stringify(server.command));
-			push(name, "args", JSON.stringify(server.args));
-			if (Object.keys(server.env).length > 0) push(name, "env", `{ ${Object.entries(server.env).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`);
-			index += 1;
-			continue;
-		}
-		if (server.type === "sse") {
-			skipped.push({
-				name,
-				reason: "Codex speaks streamable HTTP, not SSE."
-			});
-			continue;
-		}
-		const headerNames = Object.keys(server.headers);
-		const authorization = headerNames.find((key) => key.toLowerCase() === AUTHORIZATION_HEADER);
-		const otherHeaders = headerNames.filter((key) => key !== authorization);
-		if (otherHeaders.length > 0) {
-			skipped.push({
-				name,
-				reason: `Codex sends no custom headers, and this server needs ${otherHeaders.join(", ")}.`
-			});
-			continue;
-		}
-		push(name, "url", JSON.stringify(server.url));
-		if (authorization !== void 0) {
-			const token = server.headers[authorization]?.replace(BEARER_PREFIX, "") ?? "";
-			const variable = bearerTokenEnvVar(name, index);
-			env[variable] = token;
-			push(name, "bearer_token_env_var", JSON.stringify(variable));
+//#region ../../packages/effect-codex-app-server/src/errors.ts
+const CodexAppServerRequestOperation = Schema$1.Literals([
+	"decode-payload",
+	"encode-payload",
+	"handle-request",
+	"receive-response"
+]);
+const CodexAppServerSchemaIssueKind = Schema$1.Literals([
+	"Filter",
+	"Encoding",
+	"Pointer",
+	"Composite",
+	"AnyOf",
+	"InvalidType",
+	"InvalidValue",
+	"MissingKey",
+	"UnexpectedKey",
+	"Forbidden",
+	"OneOf"
+]);
+const schemaIssueDiagnostics$1 = (root) => {
+	let issueCount = 0;
+	let maximumPathDepth = 0;
+	const issueKinds = /* @__PURE__ */ new Set();
+	const visit = (issue, pathDepth) => {
+		issueCount += 1;
+		issueKinds.add(issue._tag);
+		maximumPathDepth = Math.max(maximumPathDepth, pathDepth);
+		switch (issue._tag) {
+			case "Filter":
+			case "Encoding":
+				visit(issue.issue, pathDepth);
+				break;
+			case "Pointer":
+				visit(issue.issue, pathDepth + issue.path.length);
+				break;
+			case "Composite":
+			case "AnyOf":
+				for (const child of issue.issues) visit(child, pathDepth);
+				break;
 		}
-		index += 1;
-	}
+	};
+	visit(root, 0);
 	return {
-		args,
-		env,
-		skipped
+		issueCount,
+		issueKinds: [...issueKinds],
+		maximumPathDepth
 	};
 };
+const CodexAppServerPayloadKind = Schema$1.Literals([
+	"null",
+	"array",
+	"string",
+	"number",
+	"boolean",
+	"bigint",
+	"object",
+	"symbol",
+	"function",
+	"undefined"
+]);
+const payloadKind = (payload) => {
+	if (payload === null) return "null";
+	if (Array.isArray(payload)) return "array";
+	return typeof payload;
+};
+const protocolMessageFields = [
+	"id",
+	"method",
+	"params",
+	"result",
+	"error"
+];
+const CodexAppServerProtocolMessageField = Schema$1.Literals(protocolMessageFields);
+const CodexAppServerProtocolParseOperation = Schema$1.Literals([
+	"encode-wire-message",
+	"decode-wire-message",
+	"route-wire-message",
+	"decode-notification-payload",
+	"decode-request-payload",
+	"decode-response-payload"
+]);
+const CodexAppServerTransportOperation = Schema$1.Literals(["read-input-stream", "read-process-exit-status"]);
+const CodexAppServerIdentifierPurpose = Schema$1.Literals([
+	"provider-event",
+	"command-approval-request",
+	"file-change-approval-request",
+	"user-input-request"
+]);
+var CodexAppServerSpawnError = class extends Schema$1.TaggedErrorClass()("CodexAppServerSpawnError", {
+	command: Schema$1.optional(Schema$1.String),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return this.command ? `Failed to spawn Codex App Server process for command: ${this.command}` : "Failed to spawn Codex App Server process";
+	}
+};
+var CodexAppServerProcessExitedError = class extends Schema$1.TaggedErrorClass()("CodexAppServerProcessExitedError", {
+	code: Schema$1.optional(Schema$1.Number),
+	pid: Schema$1.optionalKey(Schema$1.Int),
+	cause: Schema$1.optional(Schema$1.Defect())
+}) {
+	get message() {
+		return this.code === void 0 ? "Codex App Server process exited" : `Codex App Server process exited with code ${this.code}`;
+	}
+};
+var CodexAppServerProtocolParseError = class CodexAppServerProtocolParseError extends Schema$1.TaggedErrorClass()("CodexAppServerProtocolParseError", {
+	operation: CodexAppServerProtocolParseOperation,
+	method: Schema$1.optionalKey(Schema$1.String),
+	requestId: Schema$1.optionalKey(Schema$1.String),
+	payloadKind: Schema$1.optionalKey(CodexAppServerPayloadKind),
+	presentFields: Schema$1.optionalKey(Schema$1.Array(CodexAppServerProtocolMessageField)),
+	issueCount: Schema$1.optionalKey(Schema$1.Number),
+	issueKinds: Schema$1.optionalKey(Schema$1.Array(CodexAppServerSchemaIssueKind)),
+	maximumPathDepth: Schema$1.optionalKey(Schema$1.Number),
+	cause: Schema$1.optional(Schema$1.Defect())
+}) {
+	get message() {
+		const method = this.method === void 0 ? "" : ` for method '${this.method}'`;
+		return `Codex App Server protocol operation '${this.operation}' failed${method}.`;
+	}
+	static fromSchemaError(operation, cause, context = {}) {
+		return new CodexAppServerProtocolParseError({
+			operation,
+			...context,
+			...schemaIssueDiagnostics$1(cause.issue),
+			cause
+		});
+	}
+	static fromRequestError(operation, method, cause) {
+		return new CodexAppServerProtocolParseError({
+			operation,
+			method,
+			...cause.issueCount === void 0 ? {} : { issueCount: cause.issueCount },
+			...cause.issueKinds === void 0 ? {} : { issueKinds: cause.issueKinds },
+			...cause.maximumPathDepth === void 0 ? {} : { maximumPathDepth: cause.maximumPathDepth },
+			cause
+		});
+	}
+	static fromUnroutableMessage(message) {
+		const diagnostics = { payloadKind: payloadKind(message) };
+		if (typeof message !== "object" || message === null || Array.isArray(message)) return new CodexAppServerProtocolParseError({
+			operation: "route-wire-message",
+			...diagnostics
+		});
+		const presentFields = protocolMessageFields.filter((field) => field in message);
+		const method = "method" in message && typeof message.method === "string" ? message.method : void 0;
+		const requestId = "id" in message && (typeof message.id === "string" || typeof message.id === "number") ? String(message.id) : void 0;
+		return new CodexAppServerProtocolParseError({
+			operation: "route-wire-message",
+			...diagnostics,
+			presentFields,
+			...method === void 0 ? {} : { method },
+			...requestId === void 0 ? {} : { requestId }
+		});
+	}
+};
+var CodexAppServerTransportError = class extends Schema$1.TaggedErrorClass()("CodexAppServerTransportError", {
+	operation: CodexAppServerTransportOperation,
+	pid: Schema$1.optionalKey(Schema$1.Int),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Codex App Server transport operation '${this.operation}' failed.`;
+	}
+};
+var CodexAppServerIdentifierGenerationError = class extends Schema$1.TaggedErrorClass()("CodexAppServerIdentifierGenerationError", {
+	purpose: CodexAppServerIdentifierPurpose,
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to generate Codex App Server identifier for ${this.purpose}.`;
+	}
+};
+var CodexAppServerInputStreamEndedError = class extends Schema$1.TaggedErrorClass()("CodexAppServerInputStreamEndedError", {}) {
+	get message() {
+		return "Codex App Server input stream ended.";
+	}
+};
+var CodexAppServerRequestError = class CodexAppServerRequestError extends Schema$1.TaggedErrorClass()("CodexAppServerRequestError", {
+	code: Schema$1.Number,
+	errorMessage: Schema$1.String,
+	data: Schema$1.optional(Schema$1.Unknown),
+	method: Schema$1.optionalKey(Schema$1.String),
+	requestId: Schema$1.optionalKey(Schema$1.String),
+	operation: Schema$1.optionalKey(CodexAppServerRequestOperation),
+	issueCount: Schema$1.optionalKey(Schema$1.Number),
+	issueKinds: Schema$1.optionalKey(Schema$1.Array(CodexAppServerSchemaIssueKind)),
+	maximumPathDepth: Schema$1.optionalKey(Schema$1.Number),
+	payloadKind: Schema$1.optionalKey(CodexAppServerPayloadKind),
+	cause: Schema$1.optionalKey(Schema$1.Defect())
+}) {
+	get message() {
+		return this.errorMessage;
+	}
+	static fromProtocolError(error, method, requestId) {
+		return new CodexAppServerRequestError({
+			code: error.code,
+			errorMessage: error.message,
+			...error.data !== void 0 ? { data: error.data } : {},
+			method,
+			requestId,
+			operation: "receive-response",
+			cause: error
+		});
+	}
+	static fromAppServerError(error, method) {
+		if (error._tag === "CodexAppServerRequestError") return error;
+		return CodexAppServerRequestError.internalError(`Codex App Server request handler failed for method '${method}'`, void 0, {
+			method,
+			operation: "handle-request",
+			cause: error
+		});
+	}
+	static parseError(message = "Parse error", data) {
+		return new CodexAppServerRequestError({
+			code: -32700,
+			errorMessage: message,
+			...data !== void 0 ? { data } : {}
+		});
+	}
+	static invalidRequest(message = "Invalid request", data) {
+		return new CodexAppServerRequestError({
+			code: -32600,
+			errorMessage: message,
+			...data !== void 0 ? { data } : {}
+		});
+	}
+	static methodNotFound(method) {
+		return new CodexAppServerRequestError({
+			code: -32601,
+			errorMessage: `Method not found: ${method}`
+		});
+	}
+	static invalidParams(message = "Invalid params", data, diagnostics = {}) {
+		return new CodexAppServerRequestError({
+			code: -32602,
+			errorMessage: message,
+			...data !== void 0 ? { data } : {},
+			...diagnostics
+		});
+	}
+	static invalidPayload(method, operation, cause) {
+		const diagnostics = schemaIssueDiagnostics$1(cause.issue);
+		return new CodexAppServerRequestError({
+			code: -32602,
+			errorMessage: `Invalid payload for method '${method}' during '${operation}'`,
+			data: diagnostics,
+			method,
+			operation,
+			...diagnostics,
+			cause
+		});
+	}
+	static unexpectedPayload(method, operation, payload) {
+		const diagnostics = { payloadKind: payloadKind(payload) };
+		return new CodexAppServerRequestError({
+			code: -32602,
+			errorMessage: `Method '${method}' does not accept a payload during '${operation}'`,
+			data: diagnostics,
+			method,
+			operation,
+			...diagnostics
+		});
+	}
+	static internalError(message = "Internal error", data, diagnostics = {}) {
+		return new CodexAppServerRequestError({
+			code: -32603,
+			errorMessage: message,
+			...data !== void 0 ? { data } : {},
+			...diagnostics
+		});
+	}
+	static overloaded(message = "Server overloaded; retry later.", data) {
+		return new CodexAppServerRequestError({
+			code: -32001,
+			errorMessage: message,
+			...data !== void 0 ? { data } : {}
+		});
+	}
+	toProtocolError() {
+		return {
+			code: this.code,
+			message: this.errorMessage,
+			...this.data !== void 0 ? { data: this.data } : {}
+		};
+	}
+};
+const CodexAppServerError = Schema$1.Union([
+	CodexAppServerRequestError,
+	CodexAppServerSpawnError,
+	CodexAppServerProcessExitedError,
+	CodexAppServerProtocolParseError,
+	CodexAppServerTransportError,
+	CodexAppServerIdentifierGenerationError,
+	CodexAppServerInputStreamEndedError
+]);
 //#endregion
 //#region ../../packages/effect-codex-app-server/src/_internal/shared.ts
 const JsonRpcId$1 = Schema$1.Union([Schema$1.Number, Schema$1.String]);
@@ -87697,9 +87436,9 @@ function isIncomingNotification(value) {
 function isIncomingResponse(value) {
 	return isJsonRpcResponseEnvelope(value);
 }
-const encodeJsonString = Schema$1.encodeUnknownEffect(Schema$1.UnknownFromJsonString);
+const encodeJsonString$1 = Schema$1.encodeUnknownEffect(Schema$1.UnknownFromJsonString);
 const decodeJsonString = Schema$1.decodeUnknownEffect(Schema$1.UnknownFromJsonString);
-const encodeWireMessage = (message) => encodeJsonString(message).pipe(Effect.map((encoded) => `${encoded}\n`), Effect.mapError((cause) => {
+const encodeWireMessage = (message) => encodeJsonString$1(message).pipe(Effect.map((encoded) => `${encoded}\n`), Effect.mapError((cause) => {
 	const method = typeof message.method === "string" ? message.method : void 0;
 	const requestId = typeof message.id === "string" || typeof message.id === "number" ? String(message.id) : void 0;
 	return CodexAppServerProtocolParseError.fromSchemaError("encode-wire-message", cause, {
@@ -87955,6 +87694,30 @@ const makeChildProcessClient = Effect.fn("effect-codex-app-server/CodexAppServer
 	yield* Stream.runDrain(handle.stderr).pipe(Effect.ignore, Effect.forkScoped);
 	return yield* make$8(makeChildStdio$1(handle), options, makeTerminationError$1(handle));
 });
+const resolveCodexLaunchArgs = (launchArgs, environment = process.env) => environment["P4CODE_CODEX_LAUNCH_ARGS"]?.trim() || launchArgs?.trim() || "";
+const codexLaunchArgv = (launchArgs) => tokenizeCliArgs(launchArgs);
+const codexAppServerArgs = (launchArgs) => ["app-server", ...codexLaunchArgv(launchArgs)];
+const codexExecLaunchArgs = (launchArgs) => {
+	const args = codexLaunchArgv(launchArgs);
+	const execArgs = [];
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg === void 0) continue;
+		if (arg === "--strict-config" || arg.startsWith("--config=") || arg.startsWith("-c=")) execArgs.push(arg);
+		else if (arg === "--config" || arg === "-c" || arg === "--enable" || arg === "--disable") {
+			const value = args[index + 1];
+			if (value !== void 0 && !value.startsWith("-")) {
+				execArgs.push(arg, value);
+				index++;
+			}
+		} else if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) execArgs.push(arg);
+	}
+	return execArgs;
+};
+const codexSessionAppServerArgs = (appServerArgs, launchArgs) => {
+	const launchAppServerArgs = codexAppServerArgs(launchArgs);
+	return appServerArgs ? [...launchAppServerArgs, ...appServerArgs] : launchAppServerArgs;
+};
 //#endregion
 //#region src/provider/Layers/CodexProvider.ts
 const isCodexAppServerSpawnError = Schema$1.is(CodexAppServerSpawnError);
@@ -88322,6 +88085,507 @@ const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(function*
 	});
 });
 //#endregion
+//#region src/provider/Layers/CodexAccountUsage.ts
+/**
+* Codex has no `/usage` command: the limits live behind the app-server's
+* `account/*` requests. A short-lived app-server is spawned for the question and
+* torn down with the scope, the same way the capability probe does it, so asking
+* about the account never touches a running session.
+*
+* @module CodexAccountUsage
+*/
+const CODEX_ACCOUNT_USAGE_FORCE_KILL_AFTER = "2 seconds";
+const readCodexAccountUsage = Effect.fn("readCodexAccountUsage")(function* (input) {
+	const resolvedHomePath = input.homePath ? expandHomePath$3(input.homePath) : void 0;
+	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
+	const environment = {
+		...input.environment,
+		...resolvedHomePath ? { CODEX_HOME: resolvedHomePath } : {}
+	};
+	const spawnCommand = yield* resolveSpawnCommand(input.binaryPath, codexAppServerArgs(input.launchArgs), {
+		env: environment,
+		extendEnv: true
+	});
+	const child = yield* spawner.spawn(ChildProcess$1.make(spawnCommand.command, spawnCommand.args, {
+		cwd: input.cwd,
+		env: environment,
+		extendEnv: true,
+		forceKillAfter: CODEX_ACCOUNT_USAGE_FORCE_KILL_AFTER,
+		shell: spawnCommand.shell
+	})).pipe(Effect.mapError((cause) => new CodexAppServerSpawnError({
+		command: `${input.binaryPath} app-server`,
+		cause
+	})));
+	const clientContext = yield* Layer.build(layerChildProcess$1(child));
+	const client = yield* Effect.service(CodexAppServerClient).pipe(Effect.provide(clientContext));
+	yield* client.request("initialize", buildCodexInitializeParams());
+	yield* client.notify("initialized", void 0);
+	return {
+		rateLimits: yield* client.request("account/rateLimits/read", void 0),
+		usage: yield* client.request("account/usage/read", void 0).pipe(Effect.orElseSucceed(() => null))
+	};
+});
+//#endregion
+//#region src/codexModelOptions.ts
+function getCodexServiceTierOptionValue(modelSelection) {
+	return getModelSelectionStringOptionValue(modelSelection, "serviceTier") ?? (getModelSelectionBooleanOptionValue(modelSelection, "fastMode") === true ? "fast" : void 0);
+}
+//#endregion
+//#region src/textGeneration/codexUsageReport.ts
+const MINUTES_PER_HOUR = 60;
+const MINUTES_PER_DAY = 1440;
+const TOP_DAY_COUNT = 3;
+const PLAN_LABELS = {
+	free: "Free",
+	go: "Go",
+	plus: "Plus",
+	pro: "Pro",
+	prolite: "Pro Lite",
+	team: "Team",
+	business: "Business",
+	enterprise: "Enterprise",
+	edu: "Edu"
+};
+function formatNumber(value) {
+	return Math.round(value).toLocaleString("en-US");
+}
+/** `10080` reads as `7d`, `300` as `5h`: the window label the limit lines carry. */
+function formatWindowDuration(minutes) {
+	if (minutes === void 0 || minutes === null || minutes <= 0) return null;
+	if (minutes % MINUTES_PER_DAY === 0) return `${minutes / MINUTES_PER_DAY}d`;
+	if (minutes % MINUTES_PER_HOUR === 0) return `${minutes / MINUTES_PER_HOUR}h`;
+	return `${minutes}m`;
+}
+const MILLISECONDS_PER_SECOND = 1e3;
+function formatResetTime(resetsAt, timeZone) {
+	if (resetsAt === void 0 || resetsAt === null || !Number.isFinite(resetsAt)) return null;
+	const epochMs = resetsAt * MILLISECONDS_PER_SECOND;
+	return `resets ${new Intl.DateTimeFormat("en-US", {
+		month: "short",
+		day: "numeric",
+		timeZone
+	}).format(epochMs)} at ${new Intl.DateTimeFormat("en-US", {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true,
+		timeZone
+	}).format(epochMs).replace(/\s/g, "").toLowerCase()} (${timeZone})`;
+}
+function limitLabel(snapshot, fallbackId) {
+	const name = snapshot.limitName?.trim();
+	if (name) return name;
+	const id = snapshot.limitId?.trim() || fallbackId;
+	return id === "codex" ? "Codex" : id;
+}
+function limitLine(label, window, timeZone) {
+	if (!window) return null;
+	const duration = formatWindowDuration(window.windowDurationMins);
+	const resets = formatResetTime(window.resetsAt, timeZone);
+	return `${duration ? `${label} (${duration})` : label}: ${window.usedPercent}% used${resets ? ` · ${resets}` : ""}`;
+}
+/**
+* Every limit Codex knows about, not just the account-wide one: model-specific
+* limits arrive under `rateLimitsByLimitId` and are the ones that actually stop
+* a turn.
+*/
+function collectRateLimitSnapshots(response) {
+	const activeId = response.rateLimits.limitId ?? "codex";
+	const byId = response.rateLimitsByLimitId;
+	if (byId && Object.keys(byId).length > 0) return Object.entries(byId).map(([id, snapshot]) => ({
+		id,
+		snapshot
+	})).sort((left, right) => Number(right.id === activeId) - Number(left.id === activeId));
+	return [{
+		id: activeId,
+		snapshot: response.rateLimits
+	}];
+}
+function planSentence(response) {
+	const planType = response.rateLimits.planType;
+	if (!planType || planType === "unknown") return null;
+	return `You are currently using your Codex ${PLAN_LABELS[planType] ?? planType} plan.`;
+}
+function creditsSentence(response) {
+	const credits = response.rateLimits.credits;
+	if (!credits) return null;
+	if (credits.unlimited) return "Credits: unlimited.";
+	if (!credits.hasCredits) return null;
+	return credits.balance ? `Credits: ${credits.balance} available.` : "Credits available.";
+}
+function resetCreditSentence(response) {
+	const available = response.rateLimitResetCredits?.availableCount ?? 0;
+	if (available <= 0) return null;
+	return available === 1 ? "1 rate limit reset is available on this account." : `${available} rate limit resets are available on this account.`;
+}
+const MONTH_NAMES = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+/** A stat line only earns its place when the account actually reports the number. */
+function countStat(value, label) {
+	if (value === void 0 || value === null || value <= 0) return null;
+	return `${formatNumber(value)} ${label}`;
+}
+/** Buckets are calendar days (`2026-08-17`), read as written rather than as an instant. */
+function formatBucketDay(startDate) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(startDate);
+	const month = MONTH_NAMES[Number(match?.[2]) - 1];
+	if (!match || !month) return startDate;
+	return `${month} ${Number(match[3])}`;
+}
+function usageWindowLines(usage) {
+	const lines = [];
+	const buckets = (usage.dailyUsageBuckets ?? []).filter((bucket) => bucket.tokens > 0);
+	const bucketTotal = buckets.reduce((total, bucket) => total + bucket.tokens, 0);
+	if (buckets.length > 0 && bucketTotal > 0) {
+		const perDay = Math.round(bucketTotal / buckets.length);
+		lines.push(`Last ${buckets.length}d · ${formatNumber(bucketTotal)} tokens · ${formatNumber(perDay)} tokens per day`);
+		const topDays = [...buckets].sort((left, right) => right.tokens - left.tokens).slice(0, TOP_DAY_COUNT).map((bucket) => `${formatBucketDay(bucket.startDate)} ${Math.round(bucket.tokens / bucketTotal * 100)}%`);
+		if (topDays.length > 0) lines.push(`  Top days: ${topDays.join(", ")}`);
+	}
+	const summary = usage.summary;
+	const allTimeStats = [
+		countStat(summary.lifetimeTokens, "tokens"),
+		countStat(summary.peakDailyTokens, "peak daily tokens"),
+		countStat(summary.currentStreakDays, "day streak")
+	].filter((stat) => stat !== null);
+	if (allTimeStats.length > 0) lines.push(`All time · ${allTimeStats.join(" · ")}`);
+	return lines;
+}
+/**
+* Render the Codex account report. `timeZone` is the server's, matching how the
+* Claude CLI stamps its own reset times.
+*/
+function formatCodexUsageReport(input) {
+	const { rateLimits, usage, timeZone } = input;
+	const sections = [];
+	const intro = [
+		planSentence(rateLimits),
+		creditsSentence(rateLimits),
+		resetCreditSentence(rateLimits)
+	].filter((sentence) => sentence !== null).join("\n");
+	if (intro.length > 0) sections.push(intro);
+	const limits = collectRateLimitSnapshots(rateLimits).flatMap(({ id, snapshot }) => {
+		const label = limitLabel(snapshot, id);
+		return [limitLine(label, snapshot.primary, timeZone), limitLine(label, snapshot.secondary, timeZone)].filter((line) => line !== null);
+	});
+	if (limits.length > 0) sections.push(limits.join("\n"));
+	const windows = usage ? usageWindowLines(usage) : [];
+	if (windows.length > 0) {
+		sections.push(["What's contributing to your limits usage?", "Token totals Codex reports for this account. Day shares are of the tokens in that window."].join("\n"));
+		sections.push(windows.join("\n"));
+	}
+	return sections.join("\n\n");
+}
+//#endregion
+//#region src/textGeneration/CodexTextGeneration.ts
+const CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT = "low";
+const CODEX_TIMEOUT_MS = 18e4;
+/** The account report is a local lookup, so it should return in seconds, not minutes. */
+const USAGE_REPORT_TIMEOUT_MS = 3e4;
+const encodeJsonString = Schema$1.encodeEffect(Schema$1.UnknownFromJsonString);
+/**
+* Build a Codex text-generation closure bound to a specific `CodexSettings`
+* payload. See `makeCodexAdapter` for the overall per-instance rationale.
+*/
+const makeCodexTextGeneration = Effect.fn("makeCodexTextGeneration")(function* (codexConfig, environment) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const serverConfig = yield* Effect.service(ServerConfig$1);
+	const resolvedEnvironment = environment ?? process.env;
+	const readStreamAsString = (operation, stream) => stream.pipe(Stream.decodeText(), Stream.runFold(() => "", (acc, chunk) => acc + chunk), Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to collect process output")));
+	const writeTempFile = (operation, prefix, content) => fileSystem.makeTempFileScoped({ prefix: `p4code-${prefix}-${process.pid}-` }).pipe(Effect.tap((filePath) => fileSystem.writeFileString(filePath, content)), Effect.mapError((cause) => new TextGenerationError({
+		operation,
+		detail: `Failed to write temp file`,
+		cause
+	})));
+	const safeUnlink = (filePath) => fileSystem.remove(filePath).pipe(Effect.catch(() => Effect.void));
+	const encodeJsonForOperation = (operation, value) => encodeJsonString(value).pipe(Effect.mapError((cause) => new TextGenerationError({
+		operation,
+		detail: "Failed to encode structured output schema.",
+		cause
+	})));
+	const materializeImageAttachments = Effect.fn("materializeImageAttachments")(function* (_operation, attachments) {
+		if (!attachments || attachments.length === 0) return { imagePaths: [] };
+		const imagePaths = [];
+		for (const attachment of attachments) {
+			if (attachment.type !== "image") continue;
+			const resolvedPath = resolveAttachmentPath({
+				attachmentsDir: serverConfig.attachmentsDir,
+				attachment
+			});
+			if (!resolvedPath || !path.isAbsolute(resolvedPath)) continue;
+			const fileInfo = yield* fileSystem.stat(resolvedPath).pipe(Effect.orElseSucceed(() => null));
+			if (!fileInfo || fileInfo.type !== "File") continue;
+			imagePaths.push(resolvedPath);
+		}
+		return { imagePaths };
+	});
+	const runCodexJson = Effect.fn("runCodexJson")(function* ({ operation, cwd, prompt, outputSchemaJson, imagePaths = [], cleanupPaths = [], modelSelection }) {
+		const schemaJson = yield* encodeJsonForOperation(operation, toJsonSchemaObject(outputSchemaJson));
+		const schemaPath = yield* writeTempFile(operation, "codex-schema", schemaJson);
+		const outputPath = yield* writeTempFile(operation, "codex-output", "");
+		const runCodexCommand = Effect.fn("runCodexJson.runCodexCommand")(function* () {
+			const launchArgs = resolveCodexLaunchArgs(codexConfig.launchArgs, resolvedEnvironment);
+			const reasoningEffort = getModelSelectionStringOptionValue(modelSelection, "reasoningEffort") ?? CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT;
+			const serviceTier = getCodexServiceTierOptionValue(modelSelection);
+			const spawnCommand = yield* resolveSpawnCommand(codexConfig.binaryPath || "codex", [
+				"exec",
+				...codexExecLaunchArgs(launchArgs),
+				"--ephemeral",
+				"--skip-git-repo-check",
+				"-s",
+				"read-only",
+				"--model",
+				modelSelection.model,
+				"--config",
+				`model_reasoning_effort="${reasoningEffort}"`,
+				...serviceTier ? ["--config", `service_tier="${serviceTier}"`] : [],
+				"--output-schema",
+				schemaPath,
+				"--output-last-message",
+				outputPath,
+				...imagePaths.flatMap((imagePath) => ["--image", imagePath]),
+				"-"
+			], { env: resolvedEnvironment });
+			const command = ChildProcess.make(spawnCommand.command, spawnCommand.args, {
+				env: {
+					...resolvedEnvironment,
+					...codexConfig.homePath ? { CODEX_HOME: expandHomePath$3(codexConfig.homePath) } : {}
+				},
+				cwd,
+				shell: spawnCommand.shell,
+				stdin: { stream: Stream.encodeText(Stream.make(prompt)) }
+			});
+			const child = yield* commandSpawner.spawn(command).pipe(Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to spawn Codex CLI process")));
+			const [stdout, stderr, exitCode] = yield* Effect.all([
+				readStreamAsString(operation, child.stdout),
+				readStreamAsString(operation, child.stderr),
+				child.exitCode.pipe(Effect.mapError((cause) => normalizeCliError("codex", operation, cause, "Failed to read Codex CLI exit code")))
+			], { concurrency: "unbounded" });
+			if (exitCode !== 0) {
+				const stderrDetail = stderr.trim();
+				const stdoutDetail = stdout.trim();
+				const detail = stderrDetail.length > 0 ? stderrDetail : stdoutDetail;
+				return yield* new TextGenerationError({
+					operation,
+					detail: detail.length > 0 ? `Codex CLI command failed: ${detail}` : `Codex CLI command failed with code ${exitCode}.`
+				});
+			}
+		});
+		const cleanup = Effect.all([
+			schemaPath,
+			outputPath,
+			...cleanupPaths
+		].map((filePath) => safeUnlink(filePath)), { concurrency: "unbounded" }).pipe(Effect.asVoid);
+		return yield* Effect.gen(function* () {
+			yield* runCodexCommand().pipe(Effect.scoped, Effect.timeoutOption(CODEX_TIMEOUT_MS), Effect.flatMap(Option.match({
+				onNone: () => Effect.fail(new TextGenerationError({
+					operation,
+					detail: "Codex CLI request timed out."
+				})),
+				onSome: () => Effect.void
+			})));
+			const decodeOutput = Schema$1.decodeEffect(Schema$1.fromJsonString(outputSchemaJson));
+			return yield* fileSystem.readFileString(outputPath).pipe(Effect.mapError((cause) => new TextGenerationError({
+				operation,
+				detail: "Failed to read Codex output file.",
+				cause
+			})), Effect.flatMap(decodeOutput), Effect.catchTags({ SchemaError: (cause) => Effect.fail(new TextGenerationError({
+				operation,
+				detail: "Codex returned invalid structured output.",
+				cause
+			})) }));
+		}).pipe(Effect.ensuring(cleanup));
+	});
+	return {
+		generateCommitMessage: Effect.fn("CodexTextGeneration.generateCommitMessage")(function* (input) {
+			const { prompt, outputSchema } = buildCommitMessagePrompt({
+				branch: input.branch,
+				stagedSummary: input.stagedSummary,
+				stagedPatch: input.stagedPatch,
+				includeBranch: input.includeBranch === true,
+				policy: input.policy
+			});
+			const generated = yield* runCodexJson({
+				operation: "generateCommitMessage",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				subject: sanitizeCommitSubject(generated.subject),
+				body: generated.body.trim(),
+				..."branch" in generated && typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
+			};
+		}),
+		generatePrContent: Effect.fn("CodexTextGeneration.generatePrContent")(function* (input) {
+			const { prompt, outputSchema } = buildPrContentPrompt({
+				baseBranch: input.baseBranch,
+				headBranch: input.headBranch,
+				commitSummary: input.commitSummary,
+				diffSummary: input.diffSummary,
+				diffPatch: input.diffPatch,
+				policy: input.policy,
+				changeRequestTemplate: input.changeRequestTemplate
+			});
+			const generated = yield* runCodexJson({
+				operation: "generatePrContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				title: sanitizePrTitle(generated.title),
+				body: generated.body.trim()
+			};
+		}),
+		generateBranchName: Effect.fn("CodexTextGeneration.generateBranchName")(function* (input) {
+			const { imagePaths } = yield* materializeImageAttachments("generateBranchName", input.attachments);
+			const { prompt, outputSchema } = buildBranchNamePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			return { branch: sanitizeBranchFragment((yield* runCodexJson({
+				operation: "generateBranchName",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				imagePaths,
+				modelSelection: input.modelSelection
+			})).branch) };
+		}),
+		generateThreadTitle: Effect.fn("CodexTextGeneration.generateThreadTitle")(function* (input) {
+			const { imagePaths } = yield* materializeImageAttachments("generateThreadTitle", input.attachments);
+			const { prompt, outputSchema } = buildThreadTitlePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			return { title: sanitizeThreadTitle((yield* runCodexJson({
+				operation: "generateThreadTitle",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				imagePaths,
+				modelSelection: input.modelSelection
+			})).title) };
+		}),
+		getUsageReport: Effect.fn("CodexTextGeneration.getUsageReport")(function* () {
+			const operation = "getUsageReport";
+			const snapshot = yield* readCodexAccountUsage({
+				binaryPath: codexConfig.binaryPath || "codex",
+				...codexConfig.homePath ? { homePath: codexConfig.homePath } : {},
+				launchArgs: resolveCodexLaunchArgs(codexConfig.launchArgs, resolvedEnvironment),
+				cwd: serverConfig.cwd,
+				environment: resolvedEnvironment
+			}).pipe(Effect.mapError((cause) => new TextGenerationError({
+				operation,
+				detail: "Codex CLI could not read this account's usage.",
+				cause
+			})), Effect.scoped, Effect.timeoutOption(USAGE_REPORT_TIMEOUT_MS), Effect.flatMap(Option.match({
+				onNone: () => Effect.fail(new TextGenerationError({
+					operation,
+					detail: "Codex CLI request timed out."
+				})),
+				onSome: (value) => Effect.succeed(value)
+			})), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, commandSpawner));
+			return { report: formatCodexUsageReport({
+				rateLimits: snapshot.rateLimits,
+				usage: snapshot.usage,
+				timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+			}) };
+		})
+	};
+});
+//#endregion
+//#region src/provider/Layers/codexMcpArgs.ts
+/** Codex's own name for the token variable of p4code's built-in server. */
+const CODEX_P4CODE_BEARER_TOKEN_ENV_VAR = "P4_MCP_BEARER_TOKEN";
+/** Prefix for the per-server variables the registered servers get. */
+const BEARER_TOKEN_ENV_VAR_PREFIX = "P4_MCP_BEARER_TOKEN_";
+/** TOML bare keys; anything else has to be quoted inside the dotted path. */
+const BARE_KEY = /^[A-Za-z0-9_-]+$/;
+const AUTHORIZATION_HEADER = "authorization";
+const BEARER_PREFIX = /^Bearer\s+/;
+const configKey = (name, field) => `mcp_servers.${BARE_KEY.test(name) ? name : JSON.stringify(name)}.${field}`;
+/**
+* A variable name derived from the server's, uniquely.
+*
+* Uppercased with every character a shell would not accept replaced, which can
+* collide (`a.b` and `a-b`), so the sanitized name is the prefix and the index
+* keeps it unique. The index is stable within one call, which is all that is
+* needed: the variable and the reference to it are emitted together.
+*/
+const bearerTokenEnvVar = (name, index) => `${BEARER_TOKEN_ENV_VAR_PREFIX}${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_${index}`;
+/**
+* @param resolved - Servers keyed by name, as the registry resolved them.
+* @param exclude - Names p4code declares itself. A registration cannot displace
+*   the built-in `p4-code` server, whose per-thread credential is the only
+*   thing that makes `task_current` and the thread tools work.
+*/
+const toCodexMcpConfig = (resolved, exclude = /* @__PURE__ */ new Set()) => {
+	const args = [];
+	const env = {};
+	const skipped = [];
+	const push = (name, field, value) => {
+		args.push("-c", `${configKey(name, field)}=${value}`);
+	};
+	let index = 0;
+	for (const [name, server] of Object.entries(resolved)) {
+		if (exclude.has(name)) continue;
+		if (server.type === "stdio") {
+			push(name, "command", JSON.stringify(server.command));
+			push(name, "args", JSON.stringify(server.args));
+			if (Object.keys(server.env).length > 0) push(name, "env", `{ ${Object.entries(server.env).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`);
+			index += 1;
+			continue;
+		}
+		if (server.type === "sse") {
+			skipped.push({
+				name,
+				reason: "Codex speaks streamable HTTP, not SSE."
+			});
+			continue;
+		}
+		const headerNames = Object.keys(server.headers);
+		const authorization = headerNames.find((key) => key.toLowerCase() === AUTHORIZATION_HEADER);
+		const otherHeaders = headerNames.filter((key) => key !== authorization);
+		if (otherHeaders.length > 0) {
+			skipped.push({
+				name,
+				reason: `Codex sends no custom headers, and this server needs ${otherHeaders.join(", ")}.`
+			});
+			continue;
+		}
+		push(name, "url", JSON.stringify(server.url));
+		if (authorization !== void 0) {
+			const token = server.headers[authorization]?.replace(BEARER_PREFIX, "") ?? "";
+			const variable = bearerTokenEnvVar(name, index);
+			env[variable] = token;
+			push(name, "bearer_token_env_var", JSON.stringify(variable));
+		}
+		index += 1;
+	}
+	return {
+		args,
+		env,
+		skipped
+	};
+};
+//#endregion
 //#region src/provider/CodexDeveloperInstructions.ts
 const P4_CODE_BROWSER_TOOL_INSTRUCTIONS = `
 
@@ -105085,6 +105349,7 @@ const HANDLED_TURN_START_KEY_MAX = 1e4;
 const HANDLED_TURN_START_KEY_TTL = Duration.minutes(30);
 const DEFAULT_RUNTIME_MODE = "full-access";
 const DEFAULT_THREAD_TITLE = "New thread";
+const FUSION_BUILDER_INSTRUCTIONS = `You are the Builder in a Fusion pair. Consult your Supervisor whenever you have a question, doubt, unresolved ambiguity, or decision you cannot make confidently. Continue independently when the available evidence is sufficient. Treat Supervisor advice as a decision to evaluate and follow unless it conflicts with the user's request or verified repository state.`;
 function providerErrorLabel(value) {
 	const normalized = value?.trim();
 	return normalized && normalized.length > 0 ? normalized : "unknown";
@@ -105536,6 +105801,8 @@ const make$3 = Effect.gen(function* () {
 			"Attached PDF files are available at these local paths. Read them before answering:",
 			...documentReferenceLines
 		].filter((part) => part !== void 0).join("\n\n");
+		const isFusionBuilder = ((yield* projectionSnapshotQuery.getCommandReadModel()).threadPairs ?? []).some((pair) => pair.detachedAt === null && pair.implementerThreadId === input.threadId);
+		const fusionInput = expandedInputWithDocuments !== void 0 && isFusionBuilder ? `${FUSION_BUILDER_INSTRUCTIONS}\n\n${expandedInputWithDocuments}` : expandedInputWithDocuments;
 		const activeSession = yield* providerService.listSessions().pipe(Effect.map((sessions) => sessions.find((session) => session.threadId === input.threadId)));
 		const sessionModelSwitch = activeSession === void 0 ? "in-session" : activeSession.providerInstanceId === void 0 ? yield* new ProviderAdapterRequestError({
 			provider: providerErrorLabel(activeSession.provider),
@@ -105558,7 +105825,7 @@ const make$3 = Effect.gen(function* () {
 			staleRulesetMode: sessionRulesetMode
 		});
 		if (levelChangedMidSession) threadSessionRulesetModes.set(input.threadId, compressMode);
-		const inputWithCompressPrefix = expandedInputWithDocuments !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${expandedInputWithDocuments}` : expandedInputWithDocuments;
+		const inputWithCompressPrefix = fusionInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${fusionInput}` : fusionInput;
 		return {
 			threadId: input.threadId,
 			...inputWithCompressPrefix ? { input: inputWithCompressPrefix } : {},
@@ -106391,6 +106658,8 @@ const watcherPowers = (implementerThreadId) => `You can steer the builder:
 - thread_advise with threadId ${implementerThreadId} posts advice into the builder thread. Use it when the builder should change course, and whenever the user asks you to tell, instruct or guide the builder.
 - thread_advise with interrupt: true cancels the builder's running turn before the advice lands. Reserve it for scope drift or work that is causing damage right now.
 
+Decide questions from available evidence when you can. Ask the user when a choice needs human authority. For design-related uncertainty, spawn the provider-native Designer subagent with exact scope and relevant paths. Evaluate its result, make the decision, and return that decision to the builder with thread_advise. Designer advises you; it does not replace your judgment or communicate with the builder directly.
+
 Never call thread_watch_events repeatedly to wait for new activity, and never wait for the builder to respond: deliver your review and any advice, then end your turn. The server wakes you at the next turn boundary.`;
 /**
 * The delivery loop, restated in every review wake for the same reason the