codexuse-cli 3.6.2 → 3.6.3

package/dist/index.js

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

package/dist/server/index.mjs

@@ -19324,6 +19324,10 @@ const GitStatusResult = Struct({
 	behindCount: NonNegativeInt,
 	pr: NullOr(GitStatusPr)
 });
+const GitStatusUpdatedPayload = Struct({
+	cwd: TrimmedNonEmptyStringSchema,
+	status: GitStatusResult
+});
 const GitListBranchesResult = Struct({
 	branches: Array$1(GitBranch),
 	isRepo: Boolean$2,
@@ -19527,43 +19531,43 @@ const EDITORS = [
 	{
 		id: "cursor",
 		label: "Cursor",
-		command: "cursor",
+		commands: ["cursor"],
 		supportsGoto: true
 	},
 	{
 		id: "vscode",
 		label: "VS Code",
-		command: "code",
+		commands: ["code"],
 		supportsGoto: true
 	},
 	{
 		id: "vscode-insiders",
 		label: "VS Code Insiders",
-		command: "code-insiders",
+		commands: ["code-insiders"],
 		supportsGoto: true
 	},
 	{
 		id: "vscodium",
 		label: "VSCodium",
-		command: "codium",
+		commands: ["codium"],
 		supportsGoto: true
 	},
 	{
 		id: "zed",
 		label: "Zed",
-		command: "zed",
+		commands: ["zed", "zeditor"],
 		supportsGoto: false
 	},
 	{
 		id: "antigravity",
 		label: "Antigravity",
-		command: "agy",
+		commands: ["agy"],
 		supportsGoto: false
 	},
 	{
 		id: "file-manager",
 		label: "File Manager",
-		command: null,
+		commands: null,
 		supportsGoto: false
 	}
 ];
@@ -19641,6 +19645,8 @@ const WS_METHODS = {
 	shellOpenInEditor: "shell.openInEditor",
 	gitPull: "git.pull",
 	gitStatus: "git.status",
+	gitWatchStatus: "git.watchStatus",
+	gitUnwatchStatus: "git.unwatchStatus",
 	gitRunStackedAction: "git.runStackedAction",
 	gitListBranches: "git.listBranches",
 	gitCreateWorktree: "git.createWorktree",
@@ -19713,6 +19719,7 @@ const WS_METHODS = {
 };
 const WS_CHANNELS = {
 	gitActionProgress: "git.actionProgress",
+	gitStatusUpdated: "git.statusUpdated",
 	terminalEvent: "terminal.event",
 	serverWelcome: "server.welcome",
 	serverConfigUpdated: "server.configUpdated",
@@ -19737,6 +19744,8 @@ const WebSocketRequestBody = Union([
 	tagRequestBody(WS_METHODS.shellOpenInEditor, OpenInEditorInput),
 	tagRequestBody(WS_METHODS.gitPull, GitPullInput),
 	tagRequestBody(WS_METHODS.gitStatus, GitStatusInput),
+	tagRequestBody(WS_METHODS.gitWatchStatus, GitStatusInput),
+	tagRequestBody(WS_METHODS.gitUnwatchStatus, GitStatusInput),
 	tagRequestBody(WS_METHODS.gitRunStackedAction, GitRunStackedActionInput),
 	tagRequestBody(WS_METHODS.gitListBranches, GitListBranchesInput),
 	tagRequestBody(WS_METHODS.gitCreateWorktree, GitCreateWorktreeInput),
@@ -19862,6 +19871,7 @@ const WsPushServerWelcome = makeWsPushSchema(WS_CHANNELS.serverWelcome, WsWelcom
 const WsPushServerConfigUpdated = makeWsPushSchema(WS_CHANNELS.serverConfigUpdated, ServerConfigUpdatedPayload);
 const WsPushServerProvidersUpdated = makeWsPushSchema(WS_CHANNELS.serverProvidersUpdated, ServerProviderUpdatedPayload);
 const WsPushGitActionProgress = makeWsPushSchema(WS_CHANNELS.gitActionProgress, GitActionProgressEvent);
+const WsPushGitStatusUpdated = makeWsPushSchema(WS_CHANNELS.gitStatusUpdated, GitStatusUpdatedPayload);
 const WsPushTerminalEvent = makeWsPushSchema(WS_CHANNELS.terminalEvent, TerminalEvent);
 const WsPushProfilesSwitched = makeWsPushSchema(WS_CHANNELS.profilesSwitched, Unknown);
 const WsPushRateLimitsUpdated = makeWsPushSchema(WS_CHANNELS.rateLimitsUpdated, Unknown);
@@ -19870,6 +19880,7 @@ const WsPushCliStatusUpdated = makeWsPushSchema(WS_CHANNELS.cliStatusUpdated, Un
 const WsPushOrchestrationDomainEvent = makeWsPushSchema(ORCHESTRATION_WS_CHANNELS.domainEvent, OrchestrationEvent);
 const WsPushChannelSchema = Literals([
 	WS_CHANNELS.gitActionProgress,
+	WS_CHANNELS.gitStatusUpdated,
 	WS_CHANNELS.serverWelcome,
 	WS_CHANNELS.serverConfigUpdated,
 	WS_CHANNELS.serverProvidersUpdated,
@@ -19885,6 +19896,7 @@ const WsPush = Union([
 	WsPushServerConfigUpdated,
 	WsPushServerProvidersUpdated,
 	WsPushGitActionProgress,
+	WsPushGitStatusUpdated,
 	WsPushTerminalEvent,
 	WsPushProfilesSwitched,
 	WsPushRateLimitsUpdated,
@@ -19917,6 +19929,10 @@ const LINE_COLUMN_SUFFIX_PATTERN = /:\d+(?::\d+)?$/;
 function shouldUseGotoFlag(editor, target) {
 	return editor.supportsGoto && LINE_COLUMN_SUFFIX_PATTERN.test(target);
 }
+function resolveAvailableCommand(commands, options = {}) {
+	for (const command of commands) if (isCommandAvailable(command, options)) return command;
+	return null;
+}
 function fileManagerCommandForPlatform(platform) {
 	switch (platform) {
 		case "darwin": return "open";
@@ -19992,26 +20008,41 @@ function isCommandAvailable(command, options = {}) {
 }
 function resolveAvailableEditors(platform = process.platform, env = process.env) {
 	const available = [];
-	for (const editor of EDITORS) if (isCommandAvailable(editor.command ?? fileManagerCommandForPlatform(platform), {
-		platform,
-		env
-	})) available.push(editor.id);
+	for (const editor of EDITORS) {
+		if (editor.commands === null) {
+			if (isCommandAvailable(fileManagerCommandForPlatform(platform), {
+				platform,
+				env
+			})) available.push(editor.id);
+			continue;
+		}
+		if (resolveAvailableCommand(editor.commands, {
+			platform,
+			env
+		}) !== null) available.push(editor.id);
+	}
 	return available;
 }
 /**
 * Open - Service tag for browser/editor launch operations.
 */
 var Open = class extends Service()("t3/open") {};
-const resolveEditorLaunch = fnUntraced(function* (input, platform = process.platform) {
+const resolveEditorLaunch = fnUntraced(function* (input, platform = process.platform, env = process.env) {
 	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, input.cwd) ? {
-		command: editorDef.command,
-		args: ["--goto", input.cwd]
-	} : {
-		command: editorDef.command,
-		args: [input.cwd]
-	};
+	if (editorDef.commands) {
+		const command = resolveAvailableCommand(editorDef.commands, {
+			platform,
+			env
+		}) ?? editorDef.commands[0];
+		return shouldUseGotoFlag(editorDef, input.cwd) ? {
+			command,
+			args: ["--goto", input.cwd]
+		} : {
+			command,
+			args: [input.cwd]
+		};
+	}
 	if (editorDef.id !== "file-manager") return yield* new OpenError({ message: `Unsupported editor: ${input.editor}` });
 	return {
 		command: fileManagerCommandForPlatform(platform),
@@ -24278,10 +24309,13 @@ function projectEvent(model, event) {
 				createdAt: payload.createdAt,
 				updatedAt: payload.updatedAt
 			}, event.type, "message");
-			const cappedMessages = (thread.messages.find((entry) => entry.id === message.id) ? thread.messages.map((entry) => entry.id === message.id ? {
+			const existingMessage = thread.messages.find((entry) => entry.id === message.id);
+			const shouldRefreshImportedMessageCreatedAt = message.id.startsWith(`${payload.threadId}:`) && !message.streaming;
+			const cappedMessages = (existingMessage ? thread.messages.map((entry) => entry.id === message.id ? {
 				...entry,
 				text: message.streaming ? `${entry.text}${message.text}` : message.role === "user" && message.attachments !== void 0 ? message.text : message.text.length > 0 ? message.text : entry.text,
 				streaming: message.streaming,
+				createdAt: shouldRefreshImportedMessageCreatedAt ? message.createdAt : entry.createdAt,
 				updatedAt: message.updatedAt,
 				turnId: message.turnId,
 				...message.attachments !== void 0 ? { attachments: message.attachments } : {}
@@ -28515,6 +28549,7 @@ const makeOrchestrationProjectionPipeline = gen(function* () {
 				const existingMessage = (yield* projectionThreadMessageRepository.listByThreadId({ threadId: event.payload.threadId })).find((row) => row.messageId === event.payload.messageId);
 				const nextText = existingMessage && event.payload.streaming ? `${existingMessage.text}${event.payload.text}` : existingMessage && event.payload.text.length === 0 ? existingMessage.text : event.payload.text;
 				const nextAttachments = event.payload.attachments !== void 0 ? yield* materializeAttachmentsForProjection({ attachments: event.payload.attachments }) : existingMessage?.attachments;
+				const shouldRefreshImportedMessageCreatedAt = event.payload.messageId.startsWith(`${event.payload.threadId}:`) && !event.payload.streaming;
 				yield* projectionThreadMessageRepository.upsert({
 					messageId: event.payload.messageId,
 					threadId: event.payload.threadId,
@@ -28523,7 +28558,7 @@ const makeOrchestrationProjectionPipeline = gen(function* () {
 					text: nextText,
 					...nextAttachments !== void 0 ? { attachments: [...nextAttachments] } : {},
 					isStreaming: event.payload.streaming,
-					createdAt: existingMessage?.createdAt ?? event.payload.createdAt,
+					createdAt: existingMessage && !shouldRefreshImportedMessageCreatedAt ? existingMessage.createdAt : event.payload.createdAt,
 					updatedAt: event.payload.updatedAt
 				});
 				return;
@@ -31692,6 +31727,8 @@ const EXTERNAL_SYNC_MARKER_VERSION = 1;
 const EXTERNAL_THREAD_PAGE_SIZE = 100;
 const EXTERNAL_SYNC_FOREGROUND_THREAD_LIMIT = 8;
 const EXTERNAL_SYNC_APP_SERVER_IDLE_TTL_MS = 45e3;
+const EXTERNAL_SYNC_WATCHER_SETTLE_MS = 350;
+const EXTERNAL_SYNC_WATCH_DIRECTORY_NAMES = ["sessions", "archived_sessions"];
 const DEFAULT_IMPORTED_MODEL = "gpt-5-codex";
 function toImportedModelSelection(model) {
 	return {
@@ -31720,8 +31757,10 @@ const EXTERNAL_SYNC_APP_SERVER_CLIENT_INFO = {
 let sharedExternalSyncAppServer = null;
 let sharedExternalSyncAppServerHomePath = null;
 let sharedExternalSyncAppServerIdleTimer = null;
-let externalCodexThreadSyncWatcher = null;
+let externalCodexThreadSyncWatchers = [];
 let externalCodexThreadSyncWatcherHomePath = null;
+let externalCodexThreadSyncWatcherSettleTimer = null;
+let externalCodexThreadSyncWatcherPendingTrigger = null;
 const externalSyncAppServerLeaseCount = /* @__PURE__ */ new Map();
 let externalCodexThreadSyncRefreshQueue = null;
 function asRecord$3(value) {
@@ -31732,6 +31771,11 @@ function clearSharedExternalSyncAppServerIdleTimer() {
 	clearTimeout(sharedExternalSyncAppServerIdleTimer);
 	sharedExternalSyncAppServerIdleTimer = null;
 }
+function clearExternalCodexThreadSyncWatcherSettleTimer() {
+	if (!externalCodexThreadSyncWatcherSettleTimer) return;
+	clearTimeout(externalCodexThreadSyncWatcherSettleTimer);
+	externalCodexThreadSyncWatcherSettleTimer = null;
+}
 function incrementExternalSyncAppServerLease(appServer) {
 	externalSyncAppServerLeaseCount.set(appServer, (externalSyncAppServerLeaseCount.get(appServer) ?? 0) + 1);
 }
@@ -31798,8 +31842,10 @@ async function withExternalSyncAppServer(homePath, task) {
 	}
 }
 function closeExternalCodexThreadSyncWatcher() {
-	externalCodexThreadSyncWatcher?.close();
-	externalCodexThreadSyncWatcher = null;
+	clearExternalCodexThreadSyncWatcherSettleTimer();
+	externalCodexThreadSyncWatcherPendingTrigger = null;
+	for (const watcher of externalCodexThreadSyncWatchers) watcher.close();
+	externalCodexThreadSyncWatchers = [];
 	externalCodexThreadSyncWatcherHomePath = null;
 }
 function setExternalCodexThreadSyncRefreshQueue(queue) {
@@ -31819,26 +31865,102 @@ async function requestExternalCodexThreadSyncRefresh(trigger) {
 	}
 }
 function queueExternalCodexThreadSyncRefresh(trigger) {
-	requestExternalCodexThreadSyncRefresh(trigger);
+	externalCodexThreadSyncWatcherPendingTrigger = trigger;
+	if (externalCodexThreadSyncWatcherSettleTimer) return;
+	externalCodexThreadSyncWatcherSettleTimer = setTimeout(() => {
+		const nextTrigger = externalCodexThreadSyncWatcherPendingTrigger ?? "external-codex-thread-sync-watcher";
+		externalCodexThreadSyncWatcherPendingTrigger = null;
+		clearExternalCodexThreadSyncWatcherSettleTimer();
+		requestExternalCodexThreadSyncRefresh(nextTrigger);
+	}, EXTERNAL_SYNC_WATCHER_SETTLE_MS);
+	externalCodexThreadSyncWatcherSettleTimer.unref();
+}
+function supportsRecursiveExternalCodexThreadSyncWatcher() {
+	return process.platform === "darwin" || process.platform === "win32";
+}
+function collectExternalCodexThreadSyncDirectoryWatchPaths(rootPath) {
+	const collectedPaths = [];
+	const stack = [rootPath];
+	const seenPaths = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const currentPath = stack.pop();
+		if (!currentPath) continue;
+		const resolvedCurrentPath = path.resolve(currentPath);
+		if (seenPaths.has(resolvedCurrentPath)) continue;
+		seenPaths.add(resolvedCurrentPath);
+		let stat;
+		try {
+			stat = fs.statSync(resolvedCurrentPath);
+		} catch {
+			continue;
+		}
+		if (!stat.isDirectory()) continue;
+		collectedPaths.push(resolvedCurrentPath);
+		let entries;
+		try {
+			entries = fs.readdirSync(resolvedCurrentPath, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			stack.push(path.join(resolvedCurrentPath, entry.name));
+		}
+	}
+	return collectedPaths;
+}
+function collectExternalCodexThreadSyncWatchTargets(homePath) {
+	const recursive = supportsRecursiveExternalCodexThreadSyncWatcher();
+	const targets = [];
+	for (const relativePath of EXTERNAL_SYNC_WATCH_DIRECTORY_NAMES) {
+		const absolutePath = path.join(homePath, relativePath);
+		if (!fs.existsSync(absolutePath)) continue;
+		if (recursive) {
+			targets.push({
+				watchPath: absolutePath,
+				label: relativePath,
+				recursive: true
+			});
+			continue;
+		}
+		for (const watchPath of collectExternalCodexThreadSyncDirectoryWatchPaths(absolutePath)) targets.push({
+			watchPath,
+			label: path.relative(homePath, watchPath) || ".",
+			recursive: false
+		});
+	}
+	if (targets.length === 0) targets.push({
+		watchPath: homePath,
+		label: ".",
+		recursive
+	});
+	return targets;
 }
 function startExternalCodexThreadSyncWatcher(homePath) {
 	const resolvedHomePath = path.resolve(homePath);
-	if (externalCodexThreadSyncWatcher !== null && externalCodexThreadSyncWatcherHomePath === resolvedHomePath) return;
+	if (externalCodexThreadSyncWatchers.length > 0 && externalCodexThreadSyncWatcherHomePath === resolvedHomePath) return;
 	closeExternalCodexThreadSyncWatcher();
 	try {
-		externalCodexThreadSyncWatcher = fs.watch(resolvedHomePath, { recursive: process.platform === "darwin" || process.platform === "win32" }, (_eventType, filename) => {
-			if (filename && typeof filename === "string" && !filename.trim()) return;
-			queueExternalCodexThreadSyncRefresh(filename ?? resolvedHomePath);
-		});
-		externalCodexThreadSyncWatcherHomePath = resolvedHomePath;
-		externalCodexThreadSyncWatcher.on("error", (error) => {
-			console.warn("[t3 external thread sync] watcher error", {
-				homePath: resolvedHomePath,
-				error
+		const watchTargets = collectExternalCodexThreadSyncWatchTargets(resolvedHomePath);
+		for (const target of watchTargets) {
+			const watcher = fs.watch(target.watchPath, { recursive: target.recursive }, (_eventType, filename) => {
+				if (filename && typeof filename === "string" && !filename.trim()) return;
+				const suffix = typeof filename === "string" && filename.trim().length > 0 ? `:${filename}` : "";
+				queueExternalCodexThreadSyncRefresh(`${target.label}${suffix}`);
 			});
-			closeExternalCodexThreadSyncWatcher();
-		});
+			watcher.on("error", (error) => {
+				console.warn("[t3 external thread sync] watcher error", {
+					homePath: resolvedHomePath,
+					watchPath: target.watchPath,
+					error
+				});
+				closeExternalCodexThreadSyncWatcher();
+			});
+			externalCodexThreadSyncWatchers.push(watcher);
+		}
+		externalCodexThreadSyncWatcherHomePath = resolvedHomePath;
 	} catch (error) {
+		closeExternalCodexThreadSyncWatcher();
 		console.warn("[t3 external thread sync] failed to start watcher", {
 			homePath: resolvedHomePath,
 			error
@@ -31886,6 +32008,57 @@ function linePreview(text, fallback) {
 	if (!normalized) return fallback;
 	return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
 }
+function hasImportedVisibleUserMessageContent(payload) {
+	return firstNonEmptyString(payload.message) !== null || Array.isArray(payload.text_elements) && payload.text_elements.length > 0 || Array.isArray(payload.images) && payload.images.length > 0 || Array.isArray(payload.local_images) && payload.local_images.length > 0;
+}
+async function readImportedVisibleMessageTimeline(thread) {
+	const threadPath = resolveLegacyFilePath(firstNonEmptyString(thread.path) ?? "");
+	if (!threadPath) return null;
+	let contents;
+	try {
+		contents = await fs$1.readFile(threadPath, "utf8");
+	} catch {
+		return null;
+	}
+	const user = [];
+	const assistant = [];
+	for (const rawLine of contents.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		const record = asRecord$3(entry);
+		if (!record || asTrimmedString$1(record.type) !== "event_msg") continue;
+		const payload = asRecord$3(record.payload);
+		if (!payload) continue;
+		const timestamp = firstNonEmptyString(record.timestamp, payload.timestamp, payload.createdAt, payload.created_at);
+		if (!timestamp || !Number.isFinite(Date.parse(timestamp))) continue;
+		switch (asTrimmedString$1(payload.type)) {
+			case "user_message":
+				if (hasImportedVisibleUserMessageContent(payload)) user.push(timestamp);
+				break;
+			case "agent_message":
+				if (firstNonEmptyString(payload.message) !== null) assistant.push(timestamp);
+				break;
+		}
+	}
+	return user.length > 0 || assistant.length > 0 ? {
+		user,
+		assistant
+	} : null;
+}
+function takeImportedVisibleMessageTimestamp(timeline, role) {
+	if (!timeline) return null;
+	const queue = timeline[role];
+	const nextTimestamp = queue[0];
+	if (!nextTimestamp) return null;
+	queue.shift();
+	return nextTimestamp;
+}
 function listThreadSummariesFromResponse(payload) {
 	const root = asRecord$3(payload);
 	const result = asRecord$3(root?.result) ?? root;
@@ -32216,6 +32389,7 @@ async function buildThreadImportArtifacts(input) {
 	const activities = [];
 	const proposedPlans = [];
 	const turns = Array.isArray(thread.turns) ? thread.turns : [];
+	const visibleMessageTimeline = await readImportedVisibleMessageTimeline(thread);
 	let latestArtifactUpdatedAt = createdAt;
 	let latestUpdatedAt = summaryUpdatedAt;
 	for (const [turnIndex, turnEntry] of turns.entries()) {
@@ -32229,7 +32403,8 @@ async function buildThreadImportArtifacts(input) {
 			if (!item) continue;
 			const itemId = firstNonEmptyString(item.id) ?? `${turnIndex + 1}-${itemIndex + 1}`;
 			const type = asTrimmedString$1(item.type);
-			const timestamp = nextIsoFromThreadCursor(thread, cursor, item.createdAt ?? item.updatedAt ?? turn.createdAt ?? turn.updatedAt, fallbackBaseMs);
+			const visibleMessageRole = type === "userMessage" ? "user" : type === "agentMessage" ? "assistant" : null;
+			const timestamp = nextIsoFromThreadCursor(thread, cursor, (visibleMessageRole !== null ? takeImportedVisibleMessageTimestamp(visibleMessageTimeline, visibleMessageRole) : null) ?? item.createdAt ?? item.updatedAt ?? item.startedAt ?? item.completedAt ?? turn.createdAt ?? turn.updatedAt ?? turn.startedAt ?? turn.completedAt, fallbackBaseMs);
 			if (timestamp > latestArtifactUpdatedAt) latestArtifactUpdatedAt = timestamp;
 			if (timestamp > latestUpdatedAt) latestUpdatedAt = timestamp;
 			if (type === "userMessage") {
@@ -32294,7 +32469,7 @@ async function buildThreadImportArtifacts(input) {
 		}
 		const turnError = firstNonEmptyString(turn.error);
 		if (turnError) {
-			const timestamp = nextIsoFromThreadCursor(thread, cursor, turn.updatedAt ?? turn.completedAt ?? thread.updatedAt, fallbackBaseMs);
+			const timestamp = nextIsoFromThreadCursor(thread, cursor, turn.updatedAt ?? turn.completedAt ?? turn.startedAt ?? thread.updatedAt, fallbackBaseMs);
 			if (timestamp > latestArtifactUpdatedAt) latestArtifactUpdatedAt = timestamp;
 			if (timestamp > latestUpdatedAt) latestUpdatedAt = timestamp;
 			const turnKey = turnId ? turnId : TurnId.makeUnsafe(`${thread.id}:turn:${turnIndex + 1}`);
@@ -32526,6 +32701,11 @@ function latestIsoTimestamp(left, right) {
 	const rightMs = toEpochMs(right, 0);
 	return new Date(Math.max(leftMs, rightMs)).toISOString();
 }
+function shouldRefreshImportedMessage(input) {
+	const { existingMessage, nextMessage } = input;
+	if (!existingMessage) return true;
+	return existingMessage.createdAt !== nextMessage.createdAt || existingMessage.updatedAt !== nextMessage.updatedAt || existingMessage.text !== nextMessage.text || existingMessage.turnId !== nextMessage.turnId || existingMessage.streaming !== nextMessage.streaming || JSON.stringify(existingMessage.attachments ?? null) !== JSON.stringify(nextMessage.attachments ?? null);
+}
 function hasImportedThreadArtifacts(state) {
 	return state.messageIds.size > 0 || state.activityIds.size > 0 || state.planIds.size > 0;
 }
@@ -32728,7 +32908,11 @@ function importExternalThreadArtifacts(input) {
 		input.state.threadStateById.set(input.threadId, existingThreadState);
 		let importedMessageCount = 0;
 		for (const message of input.importArtifacts.messages) {
-			if (existingThreadState.messageIds.has(message.id) || shouldSkipImportedMessageForLocalContinuation({
+			const existingMessage = existingThreadReadModel?.messages.find((entry) => entry.id === message.id);
+			if (!shouldRefreshImportedMessage({
+				existingMessage,
+				nextMessage: message
+			}) || shouldSkipImportedMessageForLocalContinuation({
 				message,
 				dedupState: localContinuationDedupState
 			})) continue;
@@ -52640,6 +52824,10 @@ function sendDesktopParentMessage$1(payload) {
 		process.send(payload);
 	} catch {}
 }
+const GIT_STATUS_WATCH_REFRESH_INTERVAL_MS = 1e4;
+function fingerprintGitStatus(status) {
+	return JSON.stringify(status);
+}
 function appendSessionError(session, chunk) {
 	const normalized = compactErrorText(chunk);
 	if (!normalized) return;
@@ -52742,6 +52930,8 @@ const createServer = fn(function* () {
 	});
 	yield* addFinalizer$1(() => promise(() => accountPool.dispose()));
 	const clients = yield* make$11(/* @__PURE__ */ new Set());
+	const watchedGitStatusesByCwd = /* @__PURE__ */ new Map();
+	const watchedGitStatusCwdsByClient = /* @__PURE__ */ new WeakMap();
 	const logger = createLogger("ws");
 	const readiness = yield* makeServerReadiness;
 	function logOutgoingPush(push, recipients) {
@@ -53236,6 +53426,96 @@ const createServer = fn(function* () {
 		cause
 	})));
 	const runPromise$1 = runPromiseWith(yield* services());
+	const publishGitStatusToClient = (client, cwd, status) => pushBus.publishClient(client, WS_CHANNELS.gitStatusUpdated, {
+		cwd,
+		status
+	}).pipe(asVoid);
+	const stopGitStatusWatcher = (cwd, watcher) => {
+		clearInterval(watcher.intervalId);
+		watchedGitStatusesByCwd.delete(cwd);
+	};
+	const scheduleWatchedGitStatusRefresh = (cwd) => {
+		const watcher = watchedGitStatusesByCwd.get(cwd);
+		if (!watcher) return Promise.resolve();
+		if (watcher.refreshPromise) return watcher.refreshPromise;
+		const refreshPromise = runPromise$1(gitManager.status({ cwd }).pipe(catch_(() => succeed(null)), flatMap((status) => {
+			if (status === null) return void_$1;
+			return sync(() => {
+				const currentWatcher = watchedGitStatusesByCwd.get(cwd);
+				if (!currentWatcher) return null;
+				const nextFingerprint = fingerprintGitStatus(status);
+				const hasChanged = currentWatcher.lastFingerprint !== nextFingerprint;
+				currentWatcher.lastFingerprint = nextFingerprint;
+				currentWatcher.lastStatus = status;
+				if (!hasChanged || currentWatcher.subscribers.size === 0) return null;
+				return [...currentWatcher.subscribers];
+			}).pipe(flatMap((subscribers) => subscribers === null ? void_$1 : forEach(subscribers, (client) => publishGitStatusToClient(client, cwd, status), { discard: true })));
+		})));
+		let trackedRefreshPromise;
+		trackedRefreshPromise = refreshPromise.finally(() => {
+			const currentWatcher = watchedGitStatusesByCwd.get(cwd);
+			if (currentWatcher?.refreshPromise === trackedRefreshPromise) currentWatcher.refreshPromise = null;
+		});
+		watcher.refreshPromise = trackedRefreshPromise;
+		return trackedRefreshPromise;
+	};
+	const getOrCreateGitStatusWatcher = (cwd) => {
+		const existing = watchedGitStatusesByCwd.get(cwd);
+		if (existing) return existing;
+		const watcher = {
+			subscribers: /* @__PURE__ */ new Set(),
+			intervalId: setInterval(() => {
+				scheduleWatchedGitStatusRefresh(cwd);
+			}, GIT_STATUS_WATCH_REFRESH_INTERVAL_MS),
+			lastFingerprint: null,
+			lastStatus: null,
+			refreshPromise: null
+		};
+		watchedGitStatusesByCwd.set(cwd, watcher);
+		return watcher;
+	};
+	const removeGitStatusWatcherSubscriber = (client, cwd) => {
+		const watcher = watchedGitStatusesByCwd.get(cwd);
+		if (!watcher) return;
+		watcher.subscribers.delete(client);
+		if (watcher.subscribers.size === 0) stopGitStatusWatcher(cwd, watcher);
+	};
+	const watchGitStatusForClient = fnUntraced(function* (client, cwd) {
+		let watchedCwds = watchedGitStatusCwdsByClient.get(client);
+		if (!watchedCwds) {
+			watchedCwds = /* @__PURE__ */ new Set();
+			watchedGitStatusCwdsByClient.set(client, watchedCwds);
+		}
+		if (watchedCwds.has(cwd)) {
+			const watcher = watchedGitStatusesByCwd.get(cwd);
+			if (watcher?.lastStatus) yield* publishGitStatusToClient(client, cwd, watcher.lastStatus);
+			return;
+		}
+		watchedCwds.add(cwd);
+		const watcher = getOrCreateGitStatusWatcher(cwd);
+		watcher.subscribers.add(client);
+		if (watcher.lastStatus) {
+			yield* publishGitStatusToClient(client, cwd, watcher.lastStatus);
+			return;
+		}
+		yield* promise(() => scheduleWatchedGitStatusRefresh(cwd));
+	});
+	const unwatchGitStatusForClient = (client, cwd) => {
+		const watchedCwds = watchedGitStatusCwdsByClient.get(client);
+		if (!watchedCwds?.delete(cwd)) return;
+		if (watchedCwds.size === 0) watchedGitStatusCwdsByClient.delete(client);
+		removeGitStatusWatcherSubscriber(client, cwd);
+	};
+	const unwatchAllGitStatusForClient = (client) => {
+		const watchedCwds = watchedGitStatusCwdsByClient.get(client);
+		if (!watchedCwds) return;
+		watchedGitStatusCwdsByClient.delete(client);
+		for (const cwd of watchedCwds) removeGitStatusWatcherSubscriber(client, cwd);
+	};
+	yield* addFinalizer$1(sync(() => {
+		for (const watcher of watchedGitStatusesByCwd.values()) clearInterval(watcher.intervalId);
+		watchedGitStatusesByCwd.clear();
+	}));
 	const telegramBridge = createTelegramBridge({
 		getSnapshot: () => runPromise$1(projectionReadModelQuery.getSnapshot()),
 		getThreadSnapshot: (threadId) => runPromise$1(gen(function* () {
@@ -53410,6 +53690,18 @@ const createServer = fn(function* () {
 				const body = stripRequestTag(request.body);
 				return yield* gitManager.status(body);
 			}
+			case WS_METHODS.gitWatchStatus: {
+				const body = stripRequestTag(request.body);
+				if (!ws) return yield* new RouteRequestError({ message: "Git status watching requires a WebSocket client." });
+				yield* watchGitStatusForClient(ws, yield* normalizeProjectWorkspaceRoot(body.cwd));
+				return;
+			}
+			case WS_METHODS.gitUnwatchStatus: {
+				const body = stripRequestTag(request.body);
+				if (!ws) return yield* new RouteRequestError({ message: "Git status watching requires a WebSocket client." });
+				unwatchGitStatusForClient(ws, yield* normalizeProjectWorkspaceRoot(body.cwd));
+				return;
+			}
 			case WS_METHODS.gitPull: {
 				const body = stripRequestTag(request.body);
 				return yield* git.pullCurrentBranch(body.cwd);
@@ -53918,12 +54210,14 @@ const createServer = fn(function* () {
 			runPromise$1(handleMessage(ws, raw).pipe(ignoreCause({ log: true })));
 		});
 		ws.on("close", () => {
+			unwatchAllGitStatusForClient(ws);
 			runPromise$1(update(clients, (clients) => {
 				clients.delete(ws);
 				return clients;
 			}));
 		});
 		ws.on("error", () => {
+			unwatchAllGitStatusForClient(ws);
 			runPromise$1(update(clients, (clients) => {
 				clients.delete(ws);
 				return clients;

package/package.json

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