codexuse-cli 3.0.1 → 3.1.0

package/dist/server/index.mjs

@@ -19219,6 +19219,22 @@ const GitStackedAction = Literals([
 	"commit_push",
 	"commit_push_pr"
 ]);
+const GitActionProgressPhase = Literals([
+	"branch",
+	"commit",
+	"push",
+	"pr"
+]);
+const GitActionProgressKind = Literals([
+	"action_started",
+	"phase_started",
+	"hook_started",
+	"hook_output",
+	"hook_finished",
+	"action_finished",
+	"action_failed"
+]);
+const GitActionProgressStream = Literals(["stdout", "stderr"]);
 const GitCommitStepStatus = Literals(["created", "skipped_no_changes"]);
 const GitPushStepStatus = Literals([
 	"pushed",
@@ -19266,6 +19282,7 @@ const GitResolvedPullRequest = Struct({
 const GitStatusInput = Struct({ cwd: TrimmedNonEmptyStringSchema });
 const GitPullInput = Struct({ cwd: TrimmedNonEmptyStringSchema });
 const GitRunStackedActionInput = Struct({
+	actionId: optional$2(TrimmedNonEmptyStringSchema),
 	cwd: TrimmedNonEmptyStringSchema,
 	action: GitStackedAction,
 	commitMessage: optional$2(TrimmedNonEmptyStringSchema.check(isMaxLength(1e4))),
@@ -19371,6 +19388,61 @@ const GitPullResult = Struct({
 	branch: TrimmedNonEmptyStringSchema,
 	upstreamBranch: TrimmedNonEmptyStringSchema.pipe(NullOr)
 });
+const GitActionProgressBase = Struct({
+	actionId: TrimmedNonEmptyStringSchema,
+	cwd: TrimmedNonEmptyStringSchema,
+	action: GitStackedAction
+});
+const GitActionStartedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("action_started"),
+	phases: Array$1(GitActionProgressPhase)
+});
+const GitActionPhaseStartedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("phase_started"),
+	phase: GitActionProgressPhase,
+	label: TrimmedNonEmptyStringSchema
+});
+const GitActionHookStartedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("hook_started"),
+	hookName: TrimmedNonEmptyStringSchema
+});
+const GitActionHookOutputEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("hook_output"),
+	hookName: NullOr(TrimmedNonEmptyStringSchema),
+	stream: GitActionProgressStream,
+	text: TrimmedNonEmptyStringSchema
+});
+const GitActionHookFinishedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("hook_finished"),
+	hookName: TrimmedNonEmptyStringSchema,
+	exitCode: NullOr(Int),
+	durationMs: NullOr(NonNegativeInt)
+});
+const GitActionFinishedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("action_finished"),
+	result: GitRunStackedActionResult
+});
+const GitActionFailedEvent = Struct({
+	...GitActionProgressBase.fields,
+	kind: Literal("action_failed"),
+	phase: NullOr(GitActionProgressPhase),
+	message: TrimmedNonEmptyStringSchema
+});
+const GitActionProgressEvent = Union([
+	GitActionStartedEvent,
+	GitActionPhaseStartedEvent,
+	GitActionHookStartedEvent,
+	GitActionHookOutputEvent,
+	GitActionHookFinishedEvent,
+	GitActionFinishedEvent,
+	GitActionFailedEvent
+]);
 //#endregion
 //#region ../../packages/t3-contracts/src/keybindings.ts
 const MAX_KEYBINDING_VALUE_LENGTH = 64;
@@ -19476,27 +19548,44 @@ const EDITORS = [
 	{
 		id: "cursor",
 		label: "Cursor",
-		command: "cursor"
+		command: "cursor",
+		supportsGoto: true
 	},
 	{
 		id: "vscode",
 		label: "VS Code",
-		command: "code"
+		command: "code",
+		supportsGoto: true
+	},
+	{
+		id: "vscode-insiders",
+		label: "VS Code Insiders",
+		command: "code-insiders",
+		supportsGoto: true
+	},
+	{
+		id: "vscodium",
+		label: "VSCodium",
+		command: "codium",
+		supportsGoto: true
 	},
 	{
 		id: "zed",
 		label: "Zed",
-		command: "zed"
+		command: "zed",
+		supportsGoto: false
 	},
 	{
 		id: "antigravity",
 		label: "Antigravity",
-		command: "agy"
+		command: "agy",
+		supportsGoto: false
 	},
 	{
 		id: "file-manager",
 		label: "File Manager",
-		command: null
+		command: null,
+		supportsGoto: false
 	}
 ];
 const EditorId = Literals(EDITORS.map((e) => e.id));
@@ -19638,6 +19727,7 @@ const WS_METHODS = {
 	telemetryTrack: "telemetry.track"
 };
 const WS_CHANNELS = {
+	gitActionProgress: "git.actionProgress",
 	terminalEvent: "terminal.event",
 	serverWelcome: "server.welcome",
 	serverConfigUpdated: "server.configUpdated",
@@ -19802,6 +19892,7 @@ const makeWsPushSchema = (channel, payload) => Struct({
 const WsPushServerWelcome = makeWsPushSchema(WS_CHANNELS.serverWelcome, WsWelcomePayload);
 const WsPushServerConfigUpdated = makeWsPushSchema(WS_CHANNELS.serverConfigUpdated, ServerConfigUpdatedPayload);
 const WsPushServerProvidersUpdated = makeWsPushSchema(WS_CHANNELS.serverProvidersUpdated, ServerProviderUpdatedPayload);
+const WsPushGitActionProgress = makeWsPushSchema(WS_CHANNELS.gitActionProgress, GitActionProgressEvent);
 const WsPushTerminalEvent = makeWsPushSchema(WS_CHANNELS.terminalEvent, TerminalEvent);
 const WsPushProfilesSwitched = makeWsPushSchema(WS_CHANNELS.profilesSwitched, Unknown);
 const WsPushRateLimitsUpdated = makeWsPushSchema(WS_CHANNELS.rateLimitsUpdated, Unknown);
@@ -19809,6 +19900,7 @@ const WsPushRateLimitsState = makeWsPushSchema(WS_CHANNELS.rateLimitsState, Unkn
 const WsPushCliStatusUpdated = makeWsPushSchema(WS_CHANNELS.cliStatusUpdated, Unknown);
 const WsPushOrchestrationDomainEvent = makeWsPushSchema(ORCHESTRATION_WS_CHANNELS.domainEvent, OrchestrationEvent);
 const WsPushChannelSchema = Literals([
+	WS_CHANNELS.gitActionProgress,
 	WS_CHANNELS.serverWelcome,
 	WS_CHANNELS.serverConfigUpdated,
 	WS_CHANNELS.serverProvidersUpdated,
@@ -19823,6 +19915,7 @@ const WsPush = Union([
 	WsPushServerWelcome,
 	WsPushServerConfigUpdated,
 	WsPushServerProvidersUpdated,
+	WsPushGitActionProgress,
 	WsPushTerminalEvent,
 	WsPushProfilesSwitched,
 	WsPushRateLimitsUpdated,
@@ -19852,8 +19945,8 @@ var OpenError = class extends TaggedErrorClass()("OpenError", {
 	cause: optional$2(Defect)
 }) {};
 const LINE_COLUMN_SUFFIX_PATTERN = /:\d+(?::\d+)?$/;
-function shouldUseGotoFlag(editorId, target) {
-	return (editorId === "cursor" || editorId === "vscode") && LINE_COLUMN_SUFFIX_PATTERN.test(target);
+function shouldUseGotoFlag(editor, target) {
+	return editor.supportsGoto && LINE_COLUMN_SUFFIX_PATTERN.test(target);
 }
 function fileManagerCommandForPlatform(platform) {
 	switch (platform) {
@@ -19943,7 +20036,7 @@ var Open = class extends Service()("t3/open") {};
 const resolveEditorLaunch = fnUntraced(function* (input, platform = process.platform) {
 	const editorDef = EDITORS.find((editor) => editor.id === input.editor);
 	if (!editorDef) return yield* new OpenError({ message: `Unknown editor: ${input.editor}` });
-	if (editorDef.command) return shouldUseGotoFlag(editorDef.id, input.cwd) ? {
+	if (editorDef.command) return shouldUseGotoFlag(editorDef, input.cwd) ? {
 		command: editorDef.command,
 		args: ["--goto", input.cwd]
 	} : {
@@ -29154,16 +29247,17 @@ function getActiveOffer() {
 		checkoutBaseUrl: "https://hweihwang.gumroad.com/l/codex-use"
 	};
 }
-function buildCheckoutUrl(offer, utm) {
+function buildCheckoutUrl(offer, options) {
 	const base = offer.checkoutBaseUrl;
 	const withCoupon = offer.isActive && offer.couponCode ? `${base}/${offer.couponCode}` : base;
-	if (!utm) return withCoupon;
-	const params = new URLSearchParams();
-	params.set("utm_source", utm.source);
-	params.set("utm_medium", utm.medium);
-	if (utm.campaign) params.set("utm_campaign", utm.campaign);
-	else if (offer.campaign) params.set("utm_campaign", offer.campaign);
-	return `${withCoupon}?${params.toString()}`;
+	const url = new URL(withCoupon);
+	if (options?.directCheckout) url.searchParams.set("wanted", "true");
+	if (!options?.source || !options?.medium) return url.toString();
+	url.searchParams.set("utm_source", options.source);
+	url.searchParams.set("utm_medium", options.medium);
+	if (options.campaign) url.searchParams.set("utm_campaign", options.campaign);
+	else if (offer.campaign) url.searchParams.set("utm_campaign", offer.campaign);
+	return url.toString();
 }
 //#endregion
 //#region ../../packages/runtime-profiles/src/license/service.ts
@@ -29171,6 +29265,7 @@ const offer = getActiveOffer();
 const PRODUCT_PERMALINK = offer.productPermalink;
 const PRODUCT_ID = "3_CcyVEXt2FOMiEpPx8xzw==";
 const PRODUCT_URL = buildCheckoutUrl(offer);
+const CHECKOUT_URL = buildCheckoutUrl(offer, { directCheckout: true });
 const LICENSE_PRICE_DISPLAY = offer.isActive ? offer.salePriceDisplay : offer.basePriceDisplay;
 const BASE_PRICE_DISPLAY = offer.basePriceDisplay;
 const PROMO_CODE = offer.couponCode;
@@ -29287,6 +29382,7 @@ function toLicenseStatus(stored, overrides = {}) {
 		message: null,
 		error: stored?.lastVerificationError ?? null,
 		productUrl: PRODUCT_URL,
+		checkoutUrl: CHECKOUT_URL,
 		productId: PRODUCT_ID,
 		productPermalink: PRODUCT_PERMALINK,
 		priceDisplay: LICENSE_PRICE_DISPLAY,
@@ -35605,6 +35701,14 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 			}
 		}];
 	}
+	if (event.method === "process/stderr") return [{
+		type: "runtime.warning",
+		...runtimeEventBase(event, canonicalThreadId),
+		payload: {
+			message: event.message ?? "Codex process stderr",
+			...event.payload !== void 0 ? { detail: event.payload } : {}
+		}
+	}];
 	if (event.method === "windows/worldWritableWarning") return [{
 		type: "runtime.warning",
 		...runtimeEventBase(event, canonicalThreadId),
@@ -38143,6 +38247,20 @@ const makeGitManager = gen(function* () {
 	const gitCore = yield* GitCore;
 	const gitHubCli = yield* GitHubCli;
 	const textGeneration = yield* TextGeneration;
+	const createProgressEmitter = (input, options) => {
+		const actionId = options?.actionId ?? randomUUID();
+		const reporter = options?.progressReporter;
+		const emit = (event) => reporter ? reporter.publish({
+			actionId,
+			cwd: input.cwd,
+			action: input.action,
+			...event
+		}) : void_$1;
+		return {
+			actionId,
+			emit
+		};
+	};
 	const configurePullRequestHeadUpstream = (cwd, pullRequest, localBranch = pullRequest.headBranch) => gen(function* () {
 		const repositoryNameWithOwner = resolveHeadRepositoryNameWithOwner(pullRequest) ?? "";
 		if (repositoryNameWithOwner.length === 0) return;
@@ -38344,15 +38462,28 @@ const makeGitManager = gen(function* () {
 			commitMessage: formatCommitMessage(generated.subject, generated.body)
 		};
 	});
-	const runCommitStep = (cwd, branch, commitMessage, preResolvedSuggestion, filePaths, model) => gen(function* () {
-		const suggestion = preResolvedSuggestion ?? (yield* resolveCommitAndBranchSuggestion({
-			cwd,
-			branch,
-			...commitMessage ? { commitMessage } : {},
-			...filePaths ? { filePaths } : {},
-			...model ? { model } : {}
-		}));
+	const runCommitStep = (cwd, branch, commitMessage, preResolvedSuggestion, filePaths, model, progress) => gen(function* () {
+		let suggestion = preResolvedSuggestion;
+		if (!suggestion) {
+			if (!commitMessage?.trim()) yield* progress?.emit({
+				kind: "phase_started",
+				phase: "commit",
+				label: "Generating commit message..."
+			}) ?? void_$1;
+			suggestion = yield* resolveCommitAndBranchSuggestion({
+				cwd,
+				branch,
+				...commitMessage ? { commitMessage } : {},
+				...filePaths ? { filePaths } : {},
+				...model ? { model } : {}
+			});
+		}
 		if (!suggestion) return { status: "skipped_no_changes" };
+		yield* progress?.emit({
+			kind: "phase_started",
+			phase: "commit",
+			label: "Committing..."
+		}) ?? void_$1;
 		const { commitSha } = yield* gitCore.commit(cwd, suggestion.subject, suggestion.body);
 		return {
 			status: "created",
@@ -38555,32 +38686,79 @@ const makeGitManager = gen(function* () {
 		status,
 		resolvePullRequest,
 		preparePullRequestThread,
-		runStackedAction: fnUntraced(function* (input) {
-			const wantsPush = input.action !== "commit";
-			const wantsPr = input.action === "commit_push_pr";
-			const initialStatus = yield* gitCore.statusDetails(input.cwd);
-			if (!input.featureBranch && wantsPush && !initialStatus.branch) return yield* gitManagerError("runStackedAction", "Cannot push from detached HEAD.");
-			if (!input.featureBranch && wantsPr && !initialStatus.branch) return yield* gitManagerError("runStackedAction", "Cannot create a pull request from detached HEAD.");
-			let branchStep;
-			let commitMessageForStep = input.commitMessage;
-			let preResolvedCommitSuggestion = void 0;
-			if (input.featureBranch) {
-				const result = yield* runFeatureBranchStep(input.cwd, initialStatus.branch, input.commitMessage, input.filePaths, input.textGenerationModel);
-				branchStep = result.branchStep;
-				commitMessageForStep = result.resolvedCommitMessage;
-				preResolvedCommitSuggestion = result.resolvedCommitSuggestion;
-			} else branchStep = { status: "skipped_not_requested" };
-			const currentBranch = branchStep.name ?? initialStatus.branch;
-			const commit = yield* runCommitStep(input.cwd, currentBranch, commitMessageForStep, preResolvedCommitSuggestion, input.filePaths, input.textGenerationModel);
-			const push = wantsPush ? yield* gitCore.pushCurrentBranch(input.cwd, currentBranch) : { status: "skipped_not_requested" };
-			const pr = wantsPr ? yield* runPrStep(input.cwd, currentBranch, input.textGenerationModel) : { status: "skipped_not_requested" };
-			return {
-				action: input.action,
-				branch: branchStep,
-				commit,
-				push,
-				pr
-			};
+		runStackedAction: fnUntraced(function* (input, options) {
+			const progress = createProgressEmitter({
+				cwd: input.cwd,
+				action: input.action
+			}, options);
+			const phases = [
+				...input.featureBranch ? ["branch"] : [],
+				"commit",
+				...input.action !== "commit" ? ["push"] : [],
+				...input.action === "commit_push_pr" ? ["pr"] : []
+			];
+			let currentPhase = null;
+			return yield* gen(function* () {
+				yield* progress.emit({
+					kind: "action_started",
+					phases
+				});
+				const wantsPush = input.action !== "commit";
+				const wantsPr = input.action === "commit_push_pr";
+				const initialStatus = yield* gitCore.statusDetails(input.cwd);
+				if (!input.featureBranch && wantsPush && !initialStatus.branch) return yield* gitManagerError("runStackedAction", "Cannot push from detached HEAD.");
+				if (!input.featureBranch && wantsPr && !initialStatus.branch) return yield* gitManagerError("runStackedAction", "Cannot create a pull request from detached HEAD.");
+				let branchStep;
+				let commitMessageForStep = input.commitMessage;
+				let preResolvedCommitSuggestion = void 0;
+				if (input.featureBranch) {
+					currentPhase = "branch";
+					yield* progress.emit({
+						kind: "phase_started",
+						phase: "branch",
+						label: "Preparing feature branch..."
+					});
+					const result = yield* runFeatureBranchStep(input.cwd, initialStatus.branch, input.commitMessage, input.filePaths, input.textGenerationModel);
+					branchStep = result.branchStep;
+					commitMessageForStep = result.resolvedCommitMessage;
+					preResolvedCommitSuggestion = result.resolvedCommitSuggestion;
+				} else branchStep = { status: "skipped_not_requested" };
+				const currentBranch = branchStep.name ?? initialStatus.branch;
+				currentPhase = "commit";
+				const commit = yield* runCommitStep(input.cwd, currentBranch, commitMessageForStep, preResolvedCommitSuggestion, input.filePaths, input.textGenerationModel, progress);
+				const push = wantsPush ? yield* progress.emit({
+					kind: "phase_started",
+					phase: "push",
+					label: "Pushing..."
+				}).pipe(flatMap(() => gen(function* () {
+					currentPhase = "push";
+					return yield* gitCore.pushCurrentBranch(input.cwd, currentBranch);
+				}))) : { status: "skipped_not_requested" };
+				const pr = wantsPr ? yield* progress.emit({
+					kind: "phase_started",
+					phase: "pr",
+					label: "Creating PR..."
+				}).pipe(flatMap(() => gen(function* () {
+					currentPhase = "pr";
+					return yield* runPrStep(input.cwd, currentBranch, input.textGenerationModel);
+				}))) : { status: "skipped_not_requested" };
+				const result = {
+					action: input.action,
+					branch: branchStep,
+					commit,
+					push,
+					pr
+				};
+				yield* progress.emit({
+					kind: "action_finished",
+					result
+				});
+				return result;
+			}).pipe(catch_((error) => progress.emit({
+				kind: "action_failed",
+				phase: currentPhase,
+				message: error.message
+			}).pipe(flatMap(() => fail$1(error)))));
 		})
 	};
 });
@@ -43356,6 +43534,9 @@ const LEGACY_LICENSE_SECRET_FILE = "license.secret";
 function isRecord$3(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function isMissingPathError(error) {
+	return error.code === "ENOENT";
+}
 function resolveHomeDir() {
 	const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
 	if (!home) throw new Error("HOME is not set.");
@@ -43479,7 +43660,7 @@ async function cleanupLegacyCanonicalSources() {
 			}
 		}
 	} catch (error) {
-		logWarn("Failed cleaning legacy profile metadata:", {
+		if (!isMissingPathError(error)) logWarn("Failed cleaning legacy profile metadata:", {
 			profileHomesRoot,
 			error: error instanceof Error ? error.message : String(error)
 		});
@@ -43492,7 +43673,7 @@ async function cleanupLegacyCanonicalSources() {
 			await removeIfExists(path.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST));
 		}
 	} catch (error) {
-		logWarn("Failed cleaning legacy skills metadata:", {
+		if (!isMissingPathError(error)) logWarn("Failed cleaning legacy skills metadata:", {
 			skillsRoot,
 			error: error instanceof Error ? error.message : String(error)
 		});
@@ -44557,8 +44738,6 @@ const AGENTS_FILENAME = "AGENTS.md";
 const MANAGED_AGENTS_DIR = "agents";
 const DEFAULT_AGENT_MAX_THREADS = 6;
 const DEFAULT_AGENT_MAX_DEPTH = 1;
-const DEFAULT_AGENT_MODEL = "gpt-5-codex";
-const DEFAULT_REASONING_EFFORT = "medium";
 const RESERVED_AGENT_KEYS = new Set(["max_threads", "max_depth"]);
 function asTomlJsonMap(config) {
 	return config;
@@ -44816,13 +44995,9 @@ function ensureRoleNameAvailable(config, name, excludingName) {
 	}
 }
 function buildTemplateContent(input) {
-	const overrides = {
-		model: normalizeOptionalString(input.model) ?? DEFAULT_AGENT_MODEL,
-		model_reasoning_effort: normalizeOptionalString(input.reasoningEffort) ?? DEFAULT_REASONING_EFFORT
-	};
 	const developerInstructions = normalizeOptionalString(input.developerInstructions);
-	if (developerInstructions) overrides.developer_instructions = developerInstructions;
-	return `# Agent-specific overrides\n${ensureTrailingNewline((0, import_toml.stringify)(asTomlJsonMap(overrides)))}`;
+	if (!developerInstructions) return "";
+	return `# Agent-specific overrides\n${ensureTrailingNewline((0, import_toml.stringify)(asTomlJsonMap({ developer_instructions: developerInstructions })))}`;
 }
 async function readManagedRoleConfigPath(agentName, options) {
 	const { codexHome, config } = await loadAgentsConfig(options);
@@ -44914,11 +45089,7 @@ async function createAgentRole(payload, options) {
 	const relativeConfigPath = managedRelativeConfigForName(name);
 	const targetPath = await resolveSafeManagedAbsPathForWrite(loaded.codexHome, relativeConfigPath);
 	if (await statFile(targetPath)) throw new Error(`Target config file already exists: ${targetPath}`);
-	await saveFileContent(targetPath, buildTemplateContent({
-		model: payload.model,
-		reasoningEffort: payload.reasoningEffort,
-		developerInstructions: payload.developerInstructions
-	}));
+	await saveFileContent(targetPath, buildTemplateContent({ developerInstructions: payload.developerInstructions }));
 	try {
 		const agents = ensureRawTable(loaded.config, "agents");
 		agents[name] = {
@@ -47651,10 +47822,11 @@ function profileKey(profile) {
 * When the user is not on a Pro license and has saved more profiles than allowed,
 * this method prunes unauthorized profiles from disk (best effort; logs errors on failure).
 */
-async function loadProfilesViewData() {
+async function loadProfilesViewData(options = {}) {
+	const backgroundRefresh = options.backgroundRefresh !== false;
 	await profileManager.initialize();
 	const license = await licenseService.getCachedStatus();
-	licenseService.refreshStatusInBackground();
+	if (backgroundRefresh) licenseService.refreshStatusInBackground();
 	const { name: currentProfile, trusted: currentProfileTrusted } = await profileManager.getCurrentProfile();
 	const profiles = await profileManager.listProfiles();
 	const customGroupsByAccountKey = await profileManager.getCustomGroupsByAccountKey();
@@ -47670,10 +47842,12 @@ async function loadProfilesViewData() {
 	};
 	let enrichedProfiles = effectiveProfiles;
 	if (rateLimitEnabled) {
-		ensureRateLimitRefresher();
 		const rateLimitEligible = effectiveProfiles.filter((profile) => profile.isValid && !profile.tokenStatus?.requiresUserAction);
 		const resolvedSnapshots = await resolveRateLimitSnapshots(rateLimitEligible.map((profile) => profileKey(profile)));
-		await refreshRateLimitTelemetry(profileManager, rateLimitEligible, resolvedSnapshots);
+		if (backgroundRefresh) {
+			ensureRateLimitRefresher();
+			await refreshRateLimitTelemetry(profileManager, rateLimitEligible, resolvedSnapshots);
+		}
 		const refreshState = getRateLimitRefreshState();
 		refreshStatus = {
 			pendingAccountIds: refreshState.queuedAccountIds.slice(),
@@ -49322,7 +49496,10 @@ var TelegramBridge = class {
 		await fs$1.mkdir(path.dirname(lockPath), { recursive: true });
 		const payload = JSON.stringify({
 			pid: process.pid,
-			startedAt: nowIso()
+			parentPid: process.ppid > 0 ? process.ppid : null,
+			startedAt: nowIso(),
+			processStartSignature: this.readProcessStartSignature(process.pid),
+			ownerKind: this.getRuntimeLockOwnerKind()
 		}, null, 2);
 		try {
 			await fs$1.writeFile(lockPath, payload, {
@@ -49334,8 +49511,9 @@ var TelegramBridge = class {
 		} catch (error) {
 			if (error.code !== "EEXIST") throw error;
 		}
-		const existingPid = await this.readLockPid(lockPath);
-		if (existingPid && existingPid !== process.pid && this.isProcessAlive(existingPid)) throw new Error(`Telegram bridge already running in another process (pid ${existingPid}). Stop the other instance to avoid duplicate replies.`);
+		const existingLock = await this.readRuntimeLock(lockPath);
+		await this.tryRecoverOrphanedDesktopRuntimeLock(existingLock);
+		if (this.isActiveRuntimeLockOwner(existingLock)) throw new Error(this.buildRuntimeLockConflictMessage(existingLock));
 		await fs$1.unlink(lockPath).catch(() => void 0);
 		await fs$1.writeFile(lockPath, payload, {
 			encoding: "utf8",
@@ -49349,15 +49527,178 @@ var TelegramBridge = class {
 		if (!lockPath) return;
 		await fs$1.unlink(lockPath).catch(() => void 0);
 	}
-	async readLockPid(lockPath) {
+	async readRuntimeLock(lockPath) {
 		try {
 			const raw = await fs$1.readFile(lockPath, "utf8");
-			const pid = asNumber(JSON.parse(raw).pid);
-			return pid && pid > 0 ? Math.trunc(pid) : null;
+			const parsed = JSON.parse(raw);
+			const pid = asNumber(parsed.pid);
+			const parentPid = asNumber(parsed.parentPid);
+			return {
+				pid: pid && pid > 0 ? Math.trunc(pid) : null,
+				parentPid: parentPid && parentPid > 0 ? Math.trunc(parentPid) : null,
+				startedAt: asTrimmedString(parsed.startedAt) || null,
+				processStartSignature: asTrimmedString(parsed.processStartSignature) || null,
+				ownerKind: this.normalizeRuntimeLockOwnerKind(parsed.ownerKind)
+			};
 		} catch {
-			return null;
+			return {
+				pid: null,
+				parentPid: null,
+				startedAt: null,
+				processStartSignature: null,
+				ownerKind: "unknown"
+			};
 		}
 	}
+	isActiveRuntimeLockOwner(lock) {
+		const pid = lock.pid;
+		if (!pid || pid === process.pid) return false;
+		if (!this.isProcessAlive(pid)) return false;
+		const liveProcessStartSignature = this.readProcessStartSignature(pid);
+		if (lock.processStartSignature && liveProcessStartSignature) return lock.processStartSignature === liveProcessStartSignature;
+		const liveCommand = this.readProcessCommand(pid);
+		if (liveCommand) return this.isLikelyTelegramBridgeProcessCommand(liveCommand);
+		return true;
+	}
+	normalizeRuntimeLockOwnerKind(value) {
+		const normalized = asTrimmedString(value).toLowerCase();
+		if (normalized === "desktop-app" || normalized === "daemon") return normalized;
+		return "unknown";
+	}
+	getRuntimeLockOwnerKind() {
+		return this.normalizeRuntimeLockOwnerKind(process.env.CODEXUSE_TELEGRAM_RUNTIME_OWNER);
+	}
+	buildRuntimeLockConflictMessage(lock) {
+		const ownerKind = this.getEffectiveRuntimeLockOwnerKind(lock);
+		const pidText = lock.pid ? ` (pid ${lock.pid})` : "";
+		switch (ownerKind) {
+			case "desktop-app": return `Telegram bridge is already active in another CodexUse desktop app process${pidText}. Quit the other desktop session to avoid duplicate replies.`;
+			case "daemon": return `Telegram bridge is already active in a CodexUse daemon process${pidText}. Stop the daemon or disable Telegram there before enabling it here.`;
+			default: return `Telegram bridge is already active in another CodexUse process${pidText}. Stop the other instance to avoid duplicate replies.`;
+		}
+	}
+	getEffectiveRuntimeLockOwnerKind(lock) {
+		if (lock.ownerKind !== "unknown") return lock.ownerKind;
+		if (!lock.pid) return "unknown";
+		const command = this.readProcessCommand(lock.pid);
+		return command ? this.inferRuntimeLockOwnerKindFromCommand(command) : "unknown";
+	}
+	inferRuntimeLockOwnerKindFromCommand(command) {
+		const normalized = command.trim().toLowerCase();
+		if (!normalized) return "unknown";
+		if (normalized.includes("/.electrobun-build/") || normalized.includes(".app/contents/macos/bun") || normalized.includes("resources/app/server/dist/index")) return "desktop-app";
+		if (normalized.includes("cli/dist/server/index") || normalized.includes(" daemon ")) return "daemon";
+		return "unknown";
+	}
+	async tryRecoverOrphanedDesktopRuntimeLock(lock) {
+		const pid = lock.pid;
+		const ownerKind = this.getEffectiveRuntimeLockOwnerKind(lock);
+		if (!pid || ownerKind !== "desktop-app" || pid === process.pid) return;
+		if (!this.isProcessAlive(pid)) return;
+		const parentPid = lock.parentPid ?? this.readProcessParentPid(pid);
+		if (parentPid && parentPid !== 1 && this.isProcessAlive(parentPid)) return;
+		const command = this.readProcessCommand(pid);
+		if (command && !this.isLikelyTelegramBridgeProcessCommand(command)) return;
+		logWarn("[telegram-bridge] terminating orphaned desktop bridge owner", {
+			pid,
+			parentPid,
+			ownerKind,
+			command: command ? compactErrorText(command, 160) : null
+		});
+		await this.terminateProcess(pid);
+	}
+	readProcessParentPid(pid) {
+		if (process.platform === "win32") return null;
+		const result = spawnSync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"ppid="
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		if (result.status !== 0) return null;
+		const parentPid = asNumber(result.stdout.trim());
+		return parentPid && parentPid > 0 ? Math.trunc(parentPid) : null;
+	}
+	readProcessStartSignature(pid) {
+		if (process.platform === "win32") return null;
+		const result = spawnSync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"lstart="
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		if (result.status !== 0) return null;
+		const output = result.stdout.trim();
+		return output.length > 0 ? output : null;
+	}
+	readProcessCommand(pid) {
+		if (process.platform === "win32") return null;
+		const result = spawnSync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		if (result.status !== 0) return null;
+		const output = result.stdout.trim();
+		return output.length > 0 ? output : null;
+	}
+	isLikelyTelegramBridgeProcessCommand(command) {
+		const normalized = command.trim().toLowerCase();
+		if (!normalized) return false;
+		return [
+			"codexuse",
+			"codex-use",
+			"apps/server/dist/index",
+			"server/dist/index.mjs",
+			"cli/dist/server/index",
+			"resources/app/server/dist/index"
+		].some((needle) => normalized.includes(needle));
+	}
+	async terminateProcess(pid) {
+		if (!this.isProcessAlive(pid)) return;
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			return;
+		}
+		if (await this.waitForProcessExit(pid, 2e3)) return;
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {
+			return;
+		}
+		await this.waitForProcessExit(pid, 2e3);
+	}
+	async waitForProcessExit(pid, timeoutMs) {
+		const deadline = nowMs() + timeoutMs;
+		while (nowMs() < deadline) {
+			if (!this.isProcessAlive(pid)) return true;
+			await this.sleep(100);
+		}
+		return !this.isProcessAlive(pid);
+	}
 	isProcessAlive(pid) {
 		try {
 			process.kill(pid, 0);
@@ -50005,7 +50346,7 @@ const createServer = fn(function* () {
 		persistExternalThreadOverrideIntent,
 		runExternalCodexThreadSync
 	};
-	const routeRequest = fnUntraced(function* (request) {
+	const routeRequest = fnUntraced(function* (request, ws) {
 		const orchestrationResult = yield* handleOrchestrationRequest(request.body, orchestrationRequestContext);
 		if (orchestrationResult !== unhandledRequest) return orchestrationResult;
 		switch (request.body._tag) {
@@ -50069,7 +50410,10 @@ const createServer = fn(function* () {
 			}
 			case WS_METHODS.gitRunStackedAction: {
 				const body = stripRequestTag(request.body);
-				return yield* gitManager.runStackedAction(body);
+				return yield* gitManager.runStackedAction(body, {
+					actionId: body.actionId,
+					...ws ? { progressReporter: { publish: (event) => pushBus.publishClient(ws, WS_CHANNELS.gitActionProgress, event).pipe(asVoid) } } : {}
+				});
 			}
 			case WS_METHODS.gitResolvePullRequest: {
 				const body = stripRequestTag(request.body);
@@ -50532,7 +50876,7 @@ const createServer = fn(function* () {
 			id: "unknown",
 			error: { message: `Invalid request format: ${formatSchemaError(request.failure)}` }
 		});
-		const result = yield* exit(routeRequest(request.success));
+		const result = yield* exit(routeRequest(request.success, ws));
 		if (isFailure(result)) return yield* sendWsResponse({
 			id: request.success.id,
 			error: { message: pretty(result.cause) }