codexuse-cli 3.9.1 → 3.9.2

package/dist/index.js

@@ -10610,7 +10610,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.1" : "0.0.0";
+var VERSION = true ? "3.9.2" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {

package/dist/server/index.mjs

@@ -46821,6 +46821,7 @@ const ThreadMetaUpdateCommand = Struct({
 	origin: optional$2(ThreadOrigin),
 	branch: optional$2(NullOr(TrimmedNonEmptyString)),
 	worktreePath: optional$2(NullOr(TrimmedNonEmptyString)),
+	deletedAt: optional$2(NullOr(IsoDateTime)),
 	updatedAt: optional$2(IsoDateTime)
 });
 const ThreadRuntimeModeSetCommand = Struct({
@@ -47140,6 +47141,7 @@ const ThreadMetaUpdatedPayload$1 = Struct({
 	origin: optional$2(ThreadOrigin),
 	branch: optional$2(NullOr(TrimmedNonEmptyString)),
 	worktreePath: optional$2(NullOr(TrimmedNonEmptyString)),
+	deletedAt: optional$2(NullOr(IsoDateTime)),
 	updatedAt: IsoDateTime
 });
 const ThreadRuntimeModeSetPayload$1 = Struct({
@@ -47395,8 +47397,27 @@ const ProjectionPendingApprovalDecision = NullOr(ProviderApprovalDecision);
 const DispatchResult = Struct({ sequence: NonNegativeInt });
 const OrchestrationGetSnapshotInput = Struct({});
 const OrchestrationGetThreadSnapshotInput = Struct({ threadId: ThreadId });
-const OrchestrationSyncExternalThreadsInput = Struct({});
-const OrchestrationSyncExternalThreadsResult = Struct({ syncedAt: IsoDateTime });
+const OrchestrationSyncExternalThreadsInput = Struct({ projectId: optional$2(ProjectId) });
+const OrchestrationSyncExternalThreadsStats = Struct({
+	bootstrappedProjectCount: NonNegativeInt,
+	syncedProjectCount: NonNegativeInt,
+	createdThreadCount: NonNegativeInt,
+	restoredThreadCount: NonNegativeInt,
+	foregroundSummaryCount: NonNegativeInt,
+	foregroundHydratedThreadCount: NonNegativeInt,
+	foregroundImportedMessageCount: NonNegativeInt,
+	foregroundImportedActivityCount: NonNegativeInt,
+	foregroundImportedPlanCount: NonNegativeInt,
+	backgroundBackfillProjectCount: NonNegativeInt,
+	parityWorkspaceCount: NonNegativeInt,
+	hadErrors: Boolean$2
+});
+const OrchestrationSyncExternalThreadsResult = Struct({
+	syncedAt: IsoDateTime,
+	completed: Boolean$2,
+	queued: Boolean$2,
+	stats: optional$2(OrchestrationSyncExternalThreadsStats)
+});
 const OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
 const OrchestrationGetTurnDiffResult = ThreadTurnDiff;
 const OrchestrationGetFullThreadDiffInput = Struct({
@@ -48774,7 +48795,8 @@ const WS_CHANNELS = {
 	profilesSwitched: "profiles.switched",
 	rateLimitsUpdated: "rateLimits.updated",
 	rateLimitsState: "rateLimits.state",
-	cliStatusUpdated: "cli.statusUpdated"
+	cliStatusUpdated: "cli.statusUpdated",
+	externalThreadSyncProgress: "externalThreadSync.progress"
 };
 const tagRequestBody = (tag$1, schema) => schema.mapFields(assign({ _tag: tag(tag$1) }), { unsafePreserveChecks: true });
 const WebSocketRequestBody = Union([
@@ -48918,6 +48940,42 @@ const WsWelcomePayload = Struct({
 	bootstrapProjectId: optional$2(ProjectId),
 	bootstrapThreadId: optional$2(ThreadId)
 });
+const ExternalThreadSyncProjectProgress = Struct({
+	projectId: ProjectId,
+	workspaceRoot: TrimmedNonEmptyString,
+	title: TrimmedNonEmptyString,
+	scannedThreads: NonNegativeInt,
+	createdThreads: NonNegativeInt,
+	restoredThreads: NonNegativeInt,
+	hydratedThreads: NonNegativeInt,
+	importedMessages: NonNegativeInt,
+	importedActivities: NonNegativeInt,
+	importedPlans: NonNegativeInt
+});
+const ExternalThreadSyncProgressPayload = Struct({
+	status: Literals([
+		"started",
+		"project",
+		"completed",
+		"failed"
+	]),
+	runId: TrimmedNonEmptyString,
+	startedAt: TrimmedNonEmptyString,
+	updatedAt: TrimmedNonEmptyString,
+	finishedAt: optional$2(TrimmedNonEmptyString),
+	currentProjectIndex: NonNegativeInt,
+	totalProjects: NonNegativeInt,
+	project: optional$2(ExternalThreadSyncProjectProgress),
+	projects: optional$2(Array$1(ExternalThreadSyncProjectProgress)),
+	scannedThreads: NonNegativeInt,
+	createdThreads: NonNegativeInt,
+	restoredThreads: NonNegativeInt,
+	hydratedThreads: NonNegativeInt,
+	importedMessages: NonNegativeInt,
+	importedActivities: NonNegativeInt,
+	importedPlans: NonNegativeInt,
+	hadErrors: Boolean$2
+});
 const makeWsPushSchema = (channel, payload) => Struct({
 	type: Literal("push"),
 	sequence: WsPushSequence,
@@ -48934,6 +48992,7 @@ const WsPushProfilesSwitched = makeWsPushSchema(WS_CHANNELS.profilesSwitched, Un
 const WsPushRateLimitsUpdated = makeWsPushSchema(WS_CHANNELS.rateLimitsUpdated, Unknown);
 const WsPushRateLimitsState = makeWsPushSchema(WS_CHANNELS.rateLimitsState, Unknown);
 const WsPushCliStatusUpdated = makeWsPushSchema(WS_CHANNELS.cliStatusUpdated, Unknown);
+const WsPushExternalThreadSyncProgress = makeWsPushSchema(WS_CHANNELS.externalThreadSyncProgress, ExternalThreadSyncProgressPayload);
 const WsPushOrchestrationDomainEvent = makeWsPushSchema(ORCHESTRATION_WS_CHANNELS.domainEvent, OrchestrationEvent);
 const WsPushChannelSchema = Literals([
 	WS_CHANNELS.gitActionProgress,
@@ -48946,6 +49005,7 @@ const WsPushChannelSchema = Literals([
 	WS_CHANNELS.rateLimitsUpdated,
 	WS_CHANNELS.rateLimitsState,
 	WS_CHANNELS.cliStatusUpdated,
+	WS_CHANNELS.externalThreadSyncProgress,
 	ORCHESTRATION_WS_CHANNELS.domainEvent
 ]);
 const WsPush = Union([
@@ -48959,6 +49019,7 @@ const WsPush = Union([
 	WsPushRateLimitsUpdated,
 	WsPushRateLimitsState,
 	WsPushCliStatusUpdated,
+	WsPushExternalThreadSyncProgress,
 	WsPushOrchestrationDomainEvent
 ]);
 const WsPushEnvelopeBase = Struct({
@@ -52736,17 +52797,24 @@ const decideOrchestrationCommand = fn("decideOrchestrationCommand")(function* ({
 			};
 		}
 		case "thread.meta.update": {
-			yield* requireThread({
+			const thread = yield* requireThread({
 				readModel,
 				command,
 				threadId: command.threadId
 			});
-			if (command.projectId !== void 0) yield* requireThreadProject({
-				readModel,
-				command,
-				threadId: command.threadId,
-				projectId: command.projectId
-			});
+			if (command.projectId !== void 0) {
+				yield* requireProject({
+					readModel,
+					command,
+					projectId: command.projectId
+				});
+				if (!(thread.deletedAt !== null && command.deletedAt === null)) yield* requireThreadProject({
+					readModel,
+					command,
+					threadId: command.threadId,
+					projectId: command.projectId
+				});
+			}
 			const occurredAt = nowIso$2();
 			return {
 				...withEventBase({
@@ -52764,6 +52832,7 @@ const decideOrchestrationCommand = fn("decideOrchestrationCommand")(function* ({
 					...command.origin !== void 0 ? { origin: command.origin } : {},
 					...command.branch !== void 0 ? { branch: command.branch } : {},
 					...command.worktreePath !== void 0 ? { worktreePath: command.worktreePath } : {},
+					...command.deletedAt !== void 0 ? { deletedAt: command.deletedAt } : {},
 					updatedAt: command.updatedAt ?? occurredAt
 				}
 			};
@@ -53369,6 +53438,7 @@ function projectEvent(model, event) {
 				} : {},
 				...payload.branch !== void 0 ? { branch: payload.branch } : {},
 				...payload.worktreePath !== void 0 ? { worktreePath: payload.worktreePath } : {},
+				...payload.deletedAt !== void 0 ? { deletedAt: payload.deletedAt } : {},
 				updatedAt: payload.updatedAt
 			})
 		})));
@@ -57634,6 +57704,7 @@ const makeOrchestrationProjectionPipeline = gen(function* () {
 					...event.payload.origin !== void 0 ? { origin: event.payload.origin } : {},
 					...event.payload.branch !== void 0 ? { branch: event.payload.branch } : {},
 					...event.payload.worktreePath !== void 0 ? { worktreePath: event.payload.worktreePath } : {},
+					...event.payload.deletedAt !== void 0 ? { deletedAt: event.payload.deletedAt } : {},
 					updatedAt: event.payload.updatedAt
 				});
 				return;
@@ -61058,6 +61129,62 @@ let externalCodexThreadSyncWatcherSettleTimer = null;
 let externalCodexThreadSyncWatcherPendingTrigger = null;
 const externalSyncAppServerLeaseCount = /* @__PURE__ */ new Map();
 let externalCodexThreadSyncRefreshQueue = null;
+let externalCodexThreadSyncProgressReporter = null;
+function makeEmptyExternalThreadSyncProjectStats(syncTarget) {
+	return {
+		projectId: syncTarget.projectId,
+		workspaceRoot: syncTarget.workspace.path,
+		title: syncTarget.workspace.name,
+		scannedThreads: 0,
+		createdThreads: 0,
+		restoredThreads: 0,
+		hydratedThreads: 0,
+		importedMessages: 0,
+		importedActivities: 0,
+		importedPlans: 0
+	};
+}
+function sumExternalThreadSyncProjectStats(projects) {
+	return projects.reduce((total, project) => ({
+		scannedThreads: total.scannedThreads + project.scannedThreads,
+		createdThreads: total.createdThreads + project.createdThreads,
+		restoredThreads: total.restoredThreads + project.restoredThreads,
+		hydratedThreads: total.hydratedThreads + project.hydratedThreads,
+		importedMessages: total.importedMessages + project.importedMessages,
+		importedActivities: total.importedActivities + project.importedActivities,
+		importedPlans: total.importedPlans + project.importedPlans
+	}), {
+		scannedThreads: 0,
+		createdThreads: 0,
+		restoredThreads: 0,
+		hydratedThreads: 0,
+		importedMessages: 0,
+		importedActivities: 0,
+		importedPlans: 0
+	});
+}
+function makeExternalThreadSyncStats(input) {
+	return {
+		bootstrappedProjectCount: input?.bootstrappedProjectCount ?? 0,
+		syncedProjectCount: input?.syncedProjectCount ?? 0,
+		createdThreadCount: input?.createdThreadCount ?? 0,
+		restoredThreadCount: input?.restoredThreadCount ?? 0,
+		foregroundSummaryCount: input?.foregroundSummaryCount ?? 0,
+		foregroundHydratedThreadCount: input?.foregroundHydratedThreadCount ?? 0,
+		foregroundImportedMessageCount: input?.foregroundImportedMessageCount ?? 0,
+		foregroundImportedActivityCount: input?.foregroundImportedActivityCount ?? 0,
+		foregroundImportedPlanCount: input?.foregroundImportedPlanCount ?? 0,
+		backgroundBackfillProjectCount: input?.backgroundBackfillProjectCount ?? 0,
+		parityWorkspaceCount: input?.parityWorkspaceCount ?? 0,
+		hadErrors: input?.hadErrors ?? false
+	};
+}
+function publishExternalThreadSyncProgress(payload) {
+	if (!externalCodexThreadSyncProgressReporter) return;
+	Promise.resolve(externalCodexThreadSyncProgressReporter(payload)).catch((error) => {
+		console.warn("[t3 external thread sync] progress publish failed", { error });
+	});
+}
 function asRecord$3(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -61146,6 +61273,9 @@ function closeExternalCodexThreadSyncWatcher() {
 function setExternalCodexThreadSyncRefreshQueue(queue) {
 	externalCodexThreadSyncRefreshQueue = queue ? { offer: queue } : null;
 }
+function setExternalCodexThreadSyncProgressReporter(reporter) {
+	externalCodexThreadSyncProgressReporter = reporter;
+}
 async function requestExternalCodexThreadSyncRefresh(trigger) {
 	if (!externalCodexThreadSyncRefreshQueue) return false;
 	try {
@@ -61973,7 +62103,7 @@ async function readLegacyThreadByCandidateIds(appServer, candidateIds) {
 }
 function shouldReadLegacyThreadForImport(input) {
 	if (!input.existingThread) return true;
-	if (input.existingThread.deletedAt !== null) return false;
+	if (input.existingThread.deletedAt !== null) return input.restoreDeletedImportedThread === true;
 	if (input.forceRereadExistingThreads) return true;
 	const legacyUpdatedAtMs = toEpochMs(input.legacyThreadSummary.updatedAt ?? input.legacyThreadSummary.createdAt, 0);
 	if (legacyUpdatedAtMs <= 0) return false;
@@ -62004,6 +62134,9 @@ function shouldRefreshImportedMessage(input) {
 function hasImportedThreadArtifacts(state) {
 	return state.messageIds.size > 0 || state.activityIds.size > 0 || state.planIds.size > 0;
 }
+function shouldRestoreDeletedImportedThread(input) {
+	return input.existingThread !== void 0 && input.existingThread.deletedAt !== null && input.existingThread.origin === "external-import" && input.existingThread.projectId !== input.projectId;
+}
 function readProviderThreadIdFromResumeCursor(resumeCursor) {
 	const cursor = asRecord$3(resumeCursor);
 	return firstNonEmptyString(cursor?.threadId, cursor?.thread_id, cursor?.conversationId, cursor?.conversation_id) ?? null;
@@ -62053,6 +62186,7 @@ function syncExternalThreadSummary(input) {
 		const threadIdRaw = asTrimmedString$1(input.summary.id);
 		if (!threadIdRaw) return {
 			createdThread: false,
+			restoredThread: false,
 			overridesChanged: false
 		};
 		const threadId = ThreadId.makeUnsafe(threadIdRaw);
@@ -62070,9 +62204,14 @@ function syncExternalThreadSummary(input) {
 			orchestrationEngine: input.orchestrationEngine
 		})) return {
 			createdThread: false,
+			restoredThread: false,
 			overridesChanged
 		};
-		const effectiveUpdatedAt = existingThread ? latestIsoTimestamp(existingThread.updatedAt, updatedAt) : updatedAt;
+		const restoreDeletedImportedThread = shouldRestoreDeletedImportedThread({
+			existingThread,
+			projectId: input.projectId
+		});
+		const effectiveUpdatedAt = existingThread && existingThread.deletedAt === null ? latestIsoTimestamp(existingThread.updatedAt, updatedAt) : updatedAt;
 		const nextBranch = input.workspace.kind === "worktree" ? firstNonEmptyString(input.workspace.worktree?.branch) : null;
 		const nextWorktreePath = input.workspace.kind === "worktree" ? input.workspace.path : null;
 		if (suppressed) {
@@ -62091,18 +62230,22 @@ function syncExternalThreadSummary(input) {
 			}
 			return {
 				createdThread: false,
+				restoredThread: false,
 				overridesChanged
 			};
 		}
-		if (existingThread && existingThread.deletedAt !== null) return {
+		if (existingThread && existingThread.deletedAt !== null && !restoreDeletedImportedThread) return {
 			createdThread: false,
+			restoredThread: false,
 			overridesChanged
 		};
-		if (existingThread && existingThread.title === title && existingThread.updatedAt === effectiveUpdatedAt && existingThread.origin === "external-import" && existingThread.branch === nextBranch && existingThread.worktreePath === nextWorktreePath) return {
+		const shouldCreateThread = !input.state.threadIds.has(threadId);
+		if (existingThread && existingThread.deletedAt === null && existingThread.projectId === input.projectId && existingThread.title === title && existingThread.updatedAt === effectiveUpdatedAt && existingThread.origin === "external-import" && existingThread.branch === nextBranch && existingThread.worktreePath === nextWorktreePath) return {
 			createdThread: false,
+			restoredThread: false,
 			overridesChanged
 		};
-		if (!input.state.threadIds.has(threadId)) {
+		if (shouldCreateThread) {
 			yield* input.orchestrationEngine.dispatch({
 				type: "thread.create",
 				commandId: CommandId.makeUnsafe(makeServerCommandId()),
@@ -62124,10 +62267,12 @@ function syncExternalThreadSummary(input) {
 			type: "thread.meta.update",
 			commandId: CommandId.makeUnsafe(makeServerCommandId()),
 			threadId,
+			...existingThread?.projectId !== input.projectId ? { projectId: input.projectId } : {},
 			title,
 			origin: "external-import",
 			branch: nextBranch,
 			worktreePath: nextWorktreePath,
+			...restoreDeletedImportedThread ? { deletedAt: null } : {},
 			updatedAt: effectiveUpdatedAt
 		});
 		input.state.threadById.set(threadId, {
@@ -62142,16 +62287,28 @@ function syncExternalThreadSummary(input) {
 		});
 		return {
 			createdThread: !existingThread,
+			restoredThread: restoreDeletedImportedThread,
 			overridesChanged
 		};
 	});
 }
 function importExternalThreadArtifacts(input) {
 	return gen(function* () {
+		const existingThread = input.state.threadById.get(input.threadId);
+		const restoreDeletedImportedThread = shouldRestoreDeletedImportedThread({
+			existingThread,
+			projectId: input.projectId
+		});
+		if (existingThread?.deletedAt !== null && !restoreDeletedImportedThread) return {
+			createdThread: false,
+			importedMessageCount: 0,
+			importedActivityCount: 0,
+			importedPlanCount: 0,
+			overridesChanged: false
+		};
 		const isNewThread = !input.state.threadIds.has(input.threadId);
 		const cachedThreadState = input.state.threadStateById.get(input.threadId);
-		const existingThreadState = !isNewThread && (!cachedThreadState || cachedThreadState.messageIds.size === 0 && cachedThreadState.activityIds.size === 0 && cachedThreadState.planIds.size === 0) ? yield* loadPersistedThreadImportState(input.importStateRepositories, input.threadId).pipe(orElseSucceed(() => createEmptyThreadImportState())) : cachedThreadState ?? createEmptyThreadImportState();
-		const existingThread = input.state.threadById.get(input.threadId);
+		const existingThreadState = input.state.threadIds.has(input.threadId) && (!cachedThreadState || cachedThreadState.messageIds.size === 0 && cachedThreadState.activityIds.size === 0 && cachedThreadState.planIds.size === 0) ? yield* loadPersistedThreadImportState(input.importStateRepositories, input.threadId).pipe(orElseSucceed(() => createEmptyThreadImportState())) : cachedThreadState ?? createEmptyThreadImportState();
 		const existingThreadReadModel = input.state.threadReadModelById.get(input.threadId);
 		const localContinuationDedupState = existingThreadReadModel ? buildLocalContinuationDedupState({
 			thread: existingThreadReadModel,
@@ -62174,7 +62331,7 @@ function importExternalThreadArtifacts(input) {
 			importedPlanCount: 0,
 			overridesChanged
 		};
-		if (suppressed || existingThread && existingThread.deletedAt !== null) return {
+		if (suppressed) return {
 			createdThread: false,
 			importedMessageCount: 0,
 			importedActivityCount: 0,
@@ -62254,16 +62411,18 @@ function importExternalThreadArtifacts(input) {
 			importedActivityCount += 1;
 		}
 		const importedArtifactCount = importedMessageCount + importedPlanCount + importedActivityCount;
-		const effectiveUpdatedAt = existingThread === void 0 ? input.importArtifacts.latestUpdatedAt : importedArtifactCount === 0 ? existingThread.updatedAt : hadImportedArtifactsBeforeSync ? latestIsoTimestamp(existingThread.updatedAt, input.importArtifacts.latestUpdatedAt) : latestIsoTimestamp(existingThread.updatedAt, input.importArtifacts.latestArtifactUpdatedAt);
-		if (!isNewThread && (existingThread === void 0 || existingThread.title !== effectiveTitle || existingThread.origin !== "external-import" || existingThread.branch !== input.importArtifacts.branch || existingThread.worktreePath !== input.importArtifacts.worktreePath || existingThread.updatedAt !== effectiveUpdatedAt)) yield* input.orchestrationEngine.dispatch({
+		const effectiveUpdatedAt = existingThread === void 0 ? input.importArtifacts.latestUpdatedAt : existingThread.deletedAt !== null ? input.importArtifacts.latestUpdatedAt : importedArtifactCount === 0 ? existingThread.updatedAt : hadImportedArtifactsBeforeSync ? latestIsoTimestamp(existingThread.updatedAt, input.importArtifacts.latestUpdatedAt) : latestIsoTimestamp(existingThread.updatedAt, input.importArtifacts.latestArtifactUpdatedAt);
+		if (!isNewThread && (existingThread === void 0 || existingThread.projectId !== input.projectId || restoreDeletedImportedThread || existingThread.title !== effectiveTitle || existingThread.origin !== "external-import" || existingThread.branch !== input.importArtifacts.branch || existingThread.worktreePath !== input.importArtifacts.worktreePath || existingThread.updatedAt !== effectiveUpdatedAt)) yield* input.orchestrationEngine.dispatch({
 			type: "thread.meta.update",
 			commandId: CommandId.makeUnsafe(makeServerCommandId()),
 			threadId: input.threadId,
+			...existingThread?.projectId !== input.projectId ? { projectId: input.projectId } : {},
 			title: effectiveTitle,
 			modelSelection: input.importArtifacts.modelSelection,
 			origin: "external-import",
 			branch: input.importArtifacts.branch,
 			worktreePath: input.importArtifacts.worktreePath,
+			...restoreDeletedImportedThread ? { deletedAt: null } : {},
 			updatedAt: effectiveUpdatedAt
 		});
 		input.state.threadById.set(input.threadId, {
@@ -62413,9 +62572,9 @@ const syncPassiveImportedThreadIfNeeded = (input) => gen(function* () {
 	})).overridesChanged) yield* tryPromise(() => writeExternalThreadOverrides(input.stateDir, overridesStore)).pipe(ignore);
 	return "continue";
 });
-const runExternalCodexThreadSync = gen(function* () {
+const runExternalCodexThreadSyncWithOptions = (options) => gen(function* () {
 	const config = yield* ServerConfig$1;
-	if (config.mode !== "desktop") return;
+	if (config.mode !== "desktop") return makeExternalThreadSyncStats();
 	const orchestrationEngine = yield* OrchestrationEngineService;
 	const providerRuntimeRepository = yield* ProviderSessionRuntimeRepository;
 	const importStateRepositories = {
@@ -62457,7 +62616,7 @@ const runExternalCodexThreadSync = gen(function* () {
 	}
 	const syncTargets = [];
 	for (const project of readModel.projects) {
-		if (project.deletedAt !== null || isGeneralChatWorkspaceRoot(project.workspaceRoot) || isAgentChatWorkspaceRoot(project.workspaceRoot)) continue;
+		if (options?.projectId !== void 0 && project.id !== options.projectId || project.deletedAt !== null || isGeneralChatWorkspaceRoot(project.workspaceRoot) || isAgentChatWorkspaceRoot(project.workspaceRoot)) continue;
 		const workspaceRoot = project.workspaceRoot;
 		const rootKey = projectRootKey(workspaceRoot);
 		if (projectIdByRootKey.has(rootKey)) continue;
@@ -62475,8 +62634,8 @@ const runExternalCodexThreadSync = gen(function* () {
 		});
 	}
 	let bootstrappedProjectCount = 0;
-	let remainingBootstrapProjects = (yield* promise(() => readProjectPolicy(readModel))).remainingProjects;
-	for (const workspace of importableParityWorkspaces) {
+	let remainingBootstrapProjects = options?.projectId === void 0 ? (yield* promise(() => readProjectPolicy(readModel))).remainingProjects : 0;
+	for (const workspace of options?.projectId === void 0 ? importableParityWorkspaces : []) {
 		const workspaceRoot = workspace.path;
 		const workspaceRootCanonicalKey = projectRootKey(workspaceRoot);
 		if (projectIdByRootKey.has(workspaceRootCanonicalKey)) continue;
@@ -62519,28 +62678,67 @@ const runExternalCodexThreadSync = gen(function* () {
 		bootstrappedProjectCount += 1;
 		if (remainingBootstrapProjects !== null && remainingBootstrapProjects > 0) remainingBootstrapProjects -= 1;
 	}
-	if (syncTargets.length === 0) return;
+	let hadErrors = false;
+	const syncRunId = crypto.randomUUID();
+	const syncStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const projectStatsByProjectId = new Map(syncTargets.map((target) => [target.projectId, makeEmptyExternalThreadSyncProjectStats(target)]));
+	const publishSyncProgress = (status, input) => {
+		const projects = Array.from(projectStatsByProjectId.values());
+		const totals = sumExternalThreadSyncProjectStats(projects);
+		publishExternalThreadSyncProgress({
+			status,
+			runId: syncRunId,
+			startedAt: syncStartedAt,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...input?.finishedAt ? { finishedAt: input.finishedAt } : {},
+			currentProjectIndex: input?.currentProjectIndex ?? 0,
+			totalProjects: syncTargets.length,
+			...input?.project ? { project: input.project } : {},
+			...status === "completed" || status === "failed" ? { projects } : {},
+			...totals,
+			hadErrors
+		});
+	};
+	if (syncTargets.length === 0) {
+		publishSyncProgress("completed", { finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+		return makeExternalThreadSyncStats({
+			bootstrappedProjectCount,
+			parityWorkspaceCount: importableParityWorkspaces.length
+		});
+	}
+	publishSyncProgress("started");
 	let createdThreadCount = 0;
+	let restoredThreadCount = 0;
 	let foregroundSummaryCount = 0;
 	let foregroundHydratedThreadCount = 0;
 	let foregroundImportedMessageCount = 0;
 	let foregroundImportedActivityCount = 0;
 	let foregroundImportedPlanCount = 0;
-	let hadErrors = false;
 	const backgroundBackfillPlans = [];
 	const lease = yield* tryPromise(() => acquireExternalSyncAppServer(runtimeContext.codexHomePath));
 	try {
 		const appServer = lease.appServer;
-		for (const syncTarget of syncTargets) {
+		for (const [syncTargetIndex, syncTarget] of syncTargets.entries()) {
 			const { projectId, workspace } = syncTarget;
+			const currentProjectIndex = syncTargetIndex + 1;
+			const projectStats = projectStatsByProjectId.get(projectId) ?? makeEmptyExternalThreadSyncProjectStats(syncTarget);
+			projectStatsByProjectId.set(projectId, projectStats);
+			publishSyncProgress("project", {
+				project: projectStats,
+				currentProjectIndex
+			});
 			let firstPage = null;
 			try {
 				firstPage = yield* tryPromise(() => listLegacyThreadPage(appServer, workspace, {
-					limit: EXTERNAL_SYNC_FOREGROUND_THREAD_LIMIT,
+					limit: options?.projectId !== void 0 ? EXTERNAL_THREAD_PAGE_SIZE : EXTERNAL_SYNC_FOREGROUND_THREAD_LIMIT,
 					sortKey: "updated_at"
 				}));
 			} catch (cause) {
 				hadErrors = true;
+				publishSyncProgress("project", {
+					project: projectStats,
+					currentProjectIndex
+				});
 				yield* logWarning$1("failed to list external Codex threads for project", {
 					cause,
 					projectId,
@@ -62550,15 +62748,25 @@ const runExternalCodexThreadSync = gen(function* () {
 				continue;
 			}
 			if (!firstPage) continue;
+			projectStats.scannedThreads += firstPage.threads.length;
+			publishSyncProgress("project", {
+				project: projectStats,
+				currentProjectIndex
+			});
 			for (const summary of firstPage.threads) {
 				const threadIdRaw = asTrimmedString$1(summary.id);
 				const threadId = threadIdRaw ? ThreadId.makeUnsafe(threadIdRaw) : null;
 				const existingThread = threadId ? state.threadById.get(threadId) : void 0;
 				const existingReadModelThread = threadId ? readModelThreadById.get(threadId) : void 0;
-				const shouldHydrateForegroundThread = threadIdRaw.length > 0 && (existingThread === void 0 || existingThread.deletedAt === null) && (shouldReadLegacyThreadForImport({
+				const restoreDeletedImportedThread = shouldRestoreDeletedImportedThread({
+					existingThread,
+					projectId
+				});
+				const shouldHydrateForegroundThread = threadIdRaw.length > 0 && (existingThread === void 0 || existingThread.deletedAt === null || restoreDeletedImportedThread) && (shouldReadLegacyThreadForImport({
 					existingThread,
 					legacyThreadSummary: summary,
-					forceRereadExistingThreads: false
+					forceRereadExistingThreads: false,
+					restoreDeletedImportedThread
 				}) || (existingReadModelThread ? needsExternalThreadHydration(existingReadModelThread) : false));
 				const summaryResult = yield* syncExternalThreadSummary({
 					summary,
@@ -62569,9 +62777,17 @@ const runExternalCodexThreadSync = gen(function* () {
 					orchestrationEngine
 				});
 				const createdThread = summaryResult.createdThread;
+				const restoredThread = summaryResult.restoredThread;
 				overridesChanged ||= summaryResult.overridesChanged;
 				foregroundSummaryCount += 1;
-				if (createdThread) createdThreadCount += 1;
+				if (createdThread) {
+					createdThreadCount += 1;
+					projectStats.createdThreads += 1;
+				}
+				if (restoredThread) {
+					restoredThreadCount += 1;
+					projectStats.restoredThreads += 1;
+				}
 				if (!shouldHydrateForegroundThread || threadIdRaw.length === 0) continue;
 				try {
 					const legacyThread = yield* tryPromise(() => readLegacyThread(appServer, threadIdRaw));
@@ -62596,7 +62812,15 @@ const runExternalCodexThreadSync = gen(function* () {
 					foregroundImportedMessageCount += importResult.importedMessageCount;
 					foregroundImportedActivityCount += importResult.importedActivityCount;
 					foregroundImportedPlanCount += importResult.importedPlanCount;
+					projectStats.hydratedThreads += 1;
+					projectStats.importedMessages += importResult.importedMessageCount;
+					projectStats.importedActivities += importResult.importedActivityCount;
+					projectStats.importedPlans += importResult.importedPlanCount;
 					overridesChanged ||= importResult.overridesChanged;
+					publishSyncProgress("project", {
+						project: projectStats,
+						currentProjectIndex
+					});
 				} catch (cause) {
 					hadErrors = true;
 					yield* logWarning$1("failed to hydrate external Codex thread during foreground sync", {
@@ -62613,6 +62837,10 @@ const runExternalCodexThreadSync = gen(function* () {
 				nextCursor: firstPage.nextCursor,
 				sortKey: "updated_at"
 			});
+			publishSyncProgress("project", {
+				project: projectStats,
+				currentProjectIndex
+			});
 		}
 	} finally {
 		yield* tryPromise(() => lease.release()).pipe(ignoreCause({ log: true }));
@@ -62634,6 +62862,7 @@ const runExternalCodexThreadSync = gen(function* () {
 		bootstrappedProjectCount,
 		syncedProjectCount: syncTargets.length,
 		createdThreadCount,
+		restoredThreadCount,
 		foregroundSummaryCount,
 		foregroundHydratedThreadCount,
 		foregroundImportedMessageCount,
@@ -62645,16 +62874,34 @@ const runExternalCodexThreadSync = gen(function* () {
 		syncMarkerVersion: importMarker?.version ?? null,
 		hadErrors
 	});
+	publishSyncProgress(hadErrors ? "failed" : "completed", { finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
 	if (!hadErrors) yield* tryPromise(() => writeImportMarker(config.stateDir, {
 		version: EXTERNAL_SYNC_MARKER_VERSION,
 		completedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		bootstrappedProjectCount,
 		syncedProjectCount: syncTargets.length,
 		createdThreadCount,
+		restoredThreadCount,
 		foregroundSummaryCount,
 		backgroundBackfillProjectCount: backgroundBackfillPlans.length
 	})).pipe(catch_((cause) => logWarning$1("failed to write external Codex thread sync marker", { cause })));
+	return makeExternalThreadSyncStats({
+		bootstrappedProjectCount,
+		syncedProjectCount: syncTargets.length,
+		createdThreadCount,
+		restoredThreadCount,
+		foregroundSummaryCount,
+		foregroundHydratedThreadCount,
+		foregroundImportedMessageCount,
+		foregroundImportedActivityCount,
+		foregroundImportedPlanCount,
+		backgroundBackfillProjectCount: backgroundBackfillPlans.length,
+		parityWorkspaceCount: importableParityWorkspaces.length,
+		hadErrors
+	});
 });
+const runExternalCodexThreadSync = runExternalCodexThreadSyncWithOptions();
+const runExternalCodexThreadSyncForProject = (projectId) => runExternalCodexThreadSyncWithOptions({ projectId });
 //#endregion
 //#region src/orchestration/Layers/ThreadSnapshotPreparation.ts
 function mapProviderSessionStatusToOrchestrationStatus(status) {
@@ -78149,9 +78396,25 @@ const handleOrchestrationRequest = fnUntraced(function* (body, context) {
 		case ORCHESTRATION_WS_METHODS.getThreadSnapshot:
 			yield* context.threadSnapshotPreparation.prepareThreadSnapshot(body.threadId);
 			return yield* context.projectionReadModelQuery.getThreadSnapshot(stripRequestTag(body));
-		case ORCHESTRATION_WS_METHODS.syncExternalThreads:
-			if (!(yield* tryPromise(() => context.requestExternalCodexThreadSyncRefresh()).pipe(orElseSucceed(() => false)))) yield* forkDetach(context.runExternalCodexThreadSync.pipe(catch_((cause) => logWarning$1("failed to sync external Codex threads", { cause }))));
-			return { syncedAt: (/* @__PURE__ */ new Date()).toISOString() };
+		case ORCHESTRATION_WS_METHODS.syncExternalThreads: {
+			const input = stripRequestTag(body);
+			if (input.projectId !== void 0) {
+				const stats = yield* context.runExternalCodexThreadSyncForProject(input.projectId);
+				return {
+					syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					completed: true,
+					queued: false,
+					stats
+				};
+			}
+			const queued = yield* tryPromise(() => context.requestExternalCodexThreadSyncRefresh()).pipe(orElseSucceed(() => false));
+			if (!queued) yield* forkDetach(context.runExternalCodexThreadSync.pipe(catch_((cause) => logWarning$1("failed to sync external Codex threads", { cause }))));
+			return {
+				syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				completed: false,
+				queued
+			};
+		}
 		case ORCHESTRATION_WS_METHODS.dispatchCommand: {
 			const normalizedCommand = yield* context.normalizeDispatchCommand({ command: body.command });
 			const overrideIntent = yield* context.resolveExternalThreadOverrideIntent(normalizedCommand);
@@ -82144,6 +82407,8 @@ const createServer = fn(function* () {
 		clients,
 		logOutgoingPush
 	});
+	setExternalCodexThreadSyncProgressReporter((payload) => runPromise(pushBus.publishAll(WS_CHANNELS.externalThreadSyncProgress, payload)));
+	yield* addFinalizer(() => sync(() => setExternalCodexThreadSyncProgressReporter(null)));
 	const agentChatConfig = getAgentChatConfig();
 	const generalChatConfig = getGeneralChatConfig();
 	yield* readiness.markPushBusReady;
@@ -82906,7 +83171,8 @@ const createServer = fn(function* () {
 		persistExternalThreadOverrideIntent,
 		dispatchOrchestrationCommand,
 		requestExternalCodexThreadSyncRefresh: () => requestExternalCodexThreadSyncRefresh("renderer-ws"),
-		runExternalCodexThreadSync
+		runExternalCodexThreadSync,
+		runExternalCodexThreadSyncForProject
 	};
 	const routeRequest = fnUntraced(function* (request, ws) {
 		const orchestrationResult = yield* handleOrchestrationRequest(request.body, orchestrationRequestContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexuse-cli",
-  "version": "3.9.1",
+  "version": "3.9.2",
   "description": "CodexUse CLI for profiles, Accounts Pool, daemon mode, licenses, and sync.",
   "author": {
     "name": "Hoang",