@aku11i/phantom 6.3.0-2 → 6.3.0-4

package/app/server/{app-BLBOjh4e.mjs → app-DS_9Jsep.mjs}

@@ -3708,6 +3708,97 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject$2(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -4978,6 +5069,39 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$1(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json.patternProperties = {};
+		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$1(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$1(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+		if (validKeyValues.length > 0) json.required = validKeyValues;
+	}
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$1(def.innerType, ctx, params);
@@ -5470,6 +5594,21 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -23446,22 +23585,40 @@ async function createGitHubClient() {
 //#endregion
 //#region ../github/src/api/checkout-target.ts
 async function listGitHubCheckoutTargets$1(owner, repo, options = {}) {
-	const { data } = await (await createGitHubClient()).issues.listForRepo({
+	const github = await createGitHubClient();
+	const perPage = options.limit ?? 30;
+	const [{ data: issues }, { data: pullRequests }] = await Promise.all([github.issues.listForRepo({
 		owner,
 		repo,
 		state: "open",
 		sort: "updated",
 		direction: "desc",
-		per_page: options.limit ?? 30
+		per_page: perPage
+	}), github.pulls.list({
+		owner,
+		repo,
+		state: "open",
+		sort: "updated",
+		direction: "desc",
+		per_page: perPage
+	}).catch(() => ({ data: [] }))]);
+	const pullRequestByNumber = new Map(pullRequests.map((pullRequest) => [pullRequest.number, pullRequest]));
+	return issues.map((item) => {
+		const pullRequest = item.pull_request ? pullRequestByNumber.get(item.number) : void 0;
+		return {
+			author: item.user?.login ?? null,
+			...pullRequest ? {
+				baseRepoFullName: pullRequest.base.repo.full_name,
+				headRef: pullRequest.head.ref,
+				headRepoFullName: pullRequest.head.repo?.full_name
+			} : {},
+			htmlUrl: item.html_url,
+			kind: item.pull_request ? "pullRequest" : "issue",
+			number: item.number,
+			title: item.title,
+			updatedAt: item.updated_at
+		};
 	});
-	return data.map((item) => ({
-		author: item.user?.login ?? null,
-		htmlUrl: item.html_url,
-		kind: item.pull_request ? "pullRequest" : "issue",
-		number: item.number,
-		title: item.title,
-		updatedAt: item.updated_at
-	}));
 }
 //#endregion
 //#region ../github/src/api/pull-request.ts
@@ -25308,6 +25465,19 @@ function summarizeCodexEvent(method, params) {
 	}
 	return method;
 }
+function rememberRecentProjectSkillSelection(recordsByProject, projectId, skillPath, lastUsedAt = (/* @__PURE__ */ new Date()).toISOString(), limit = 5) {
+	const nextProjectRecords = [{
+		path: skillPath,
+		lastUsedAt
+	}, ...(recordsByProject[projectId] ?? []).filter((record) => record.path !== skillPath)].sort((left, right) => right.lastUsedAt.localeCompare(left.lastUsedAt)).slice(0, Math.max(0, limit));
+	return {
+		...recordsByProject,
+		[projectId]: nextProjectRecords
+	};
+}
+function getRecentProjectSkillRecords(recordsByProject, projectId) {
+	return recordsByProject[projectId] ?? [];
+}
 //#endregion
 //#region ../state/src/types.ts
 const chatStatusSchema = _enum([
@@ -25351,6 +25521,11 @@ const turnContextItemBaseSchema = object({
 	name: string(),
 	path: string()
 });
+const recentProjectSkillRecordBaseSchema = object({
+	path: string(),
+	lastUsedAt: string()
+});
+const recentProjectSkillsByProjectBaseSchema = record(string(), array(recentProjectSkillRecordBaseSchema)).default({});
 const queuedMessageRecordBaseSchema = object({
 	id: string(),
 	chatId: string(),
@@ -25386,12 +25561,14 @@ object({
 	chats: array(chatRecordBaseSchema),
 	messages: array(chatMessageRecordBaseSchema),
 	queuedMessages: array(queuedMessageRecordBaseSchema).default([]),
+	recentProjectSkills: recentProjectSkillsByProjectBaseSchema,
 	selectedProjectId: nullableStringFromUnknownSchema,
 	selectedChatId: nullableStringFromUnknownSchema
 });
 const projectRecordSchema = projectRecordBaseSchema.passthrough();
 const chatMessageRecordSchema = chatMessageRecordBaseSchema.passthrough();
 const queuedMessageRecordSchema = queuedMessageRecordBaseSchema.passthrough();
+const recentProjectSkillRecordSchema = recentProjectSkillRecordBaseSchema.passthrough();
 const chatRecordSchema = chatRecordBaseSchema.passthrough();
 const serveStateSchema = object({
 	version: literal(1),
@@ -25399,6 +25576,7 @@ const serveStateSchema = object({
 	chats: array(chatRecordSchema),
 	messages: array(chatMessageRecordSchema),
 	queuedMessages: array(queuedMessageRecordSchema).default([]),
+	recentProjectSkills: record(string(), array(recentProjectSkillRecordSchema)).default({}),
 	selectedProjectId: nullableStringFromUnknownSchema,
 	selectedChatId: nullableStringFromUnknownSchema
 }).passthrough();
@@ -25415,6 +25593,7 @@ function createEmptyState() {
 		chats: [],
 		messages: [],
 		queuedMessages: [],
+		recentProjectSkills: {},
 		selectedProjectId: null,
 		selectedChatId: null
 	};
@@ -25480,7 +25659,8 @@ var ServeStateStore = class {
 				projects: [...state.projects],
 				chats: [...state.chats],
 				messages: [...state.messages],
-				queuedMessages: [...state.queuedMessages]
+				queuedMessages: [...state.queuedMessages],
+				recentProjectSkills: cloneRecentProjectSkills(state.recentProjectSkills)
 			});
 			await this.save(nextState);
 			return nextState;
@@ -25489,6 +25669,9 @@ var ServeStateStore = class {
 		return nextUpdate;
 	}
 };
+function cloneRecentProjectSkills(recordsByProject) {
+	return Object.fromEntries(Object.entries(recordsByProject).map(([projectId, records]) => [projectId, [...records]]));
+}
 function touchProject(project) {
 	const timestamp = now();
 	return {
@@ -25637,12 +25820,37 @@ var ServeServices = class {
 				chats: state.chats.filter((chat) => chat.projectId !== projectId),
 				messages: state.messages.filter((message) => !removedChatIds.has(message.chatId)),
 				queuedMessages: state.queuedMessages.filter((message) => !removedChatIds.has(message.chatId)),
+				recentProjectSkills: Object.fromEntries(Object.entries(state.recentProjectSkills).filter(([storedProjectId]) => storedProjectId !== projectId)),
 				selectedProjectId: state.selectedProjectId === projectId ? null : state.selectedProjectId,
 				selectedChatId: removedChatIds.has(state.selectedChatId ?? "") ? null : state.selectedChatId
 			};
 		});
 		this.eventHub.emit("project.removed", { projectId });
 	}
+	async listRecentProjectSkills(projectId) {
+		const state = await this.store.load();
+		const project = this.requireProject(state, projectId);
+		return normalizeRecentProjectSkillRecordPaths(getRecentProjectSkillRecords(state.recentProjectSkills, projectId), getProjectSkillRoots(state, project));
+	}
+	async rememberRecentProjectSkill(projectId, skillPath) {
+		if (!skillPath.trim()) throw new Error("Skill path is required");
+		let recentSkills = [];
+		const lastUsedAt = createTimestamp();
+		await this.store.update((state) => {
+			const projectSkillRoots = getProjectSkillRoots(state, this.requireProject(state, projectId));
+			const normalizedSkillPath = normalizeProjectSkillPath(skillPath, projectSkillRoots);
+			const recentProjectSkills = rememberRecentProjectSkillSelection({
+				...state.recentProjectSkills,
+				[projectId]: normalizeRecentProjectSkillRecordPaths(getRecentProjectSkillRecords(state.recentProjectSkills, projectId), projectSkillRoots)
+			}, projectId, normalizedSkillPath, lastUsedAt);
+			recentSkills = getRecentProjectSkillRecords(recentProjectSkills, projectId);
+			return {
+				...state,
+				recentProjectSkills
+			};
+		});
+		return recentSkills;
+	}
 	async listChats(projectId) {
 		await this.resetStaleTransientChatState();
 		const state = await this.store.load();
@@ -26054,9 +26262,12 @@ var ServeServices = class {
 		const activeTurnId = chat.activeTurnId ?? (resetChatIds.has(chatId) ? null : findLocalSteeredTurnId(localMessages));
 		if (!chat.codexThreadId) return localMessagesWithoutStaleSteeredState(chat, localMessages);
 		try {
-			const codexMessages = normalizeCodexThreadMessages(await this.codex.readThread(chat.codexThreadId, { includeTurns: true }), chat.id);
-			if (codexMessages.length === 0) return localMessagesWithoutStaleSteeredState(chat, localMessages);
-			return mergeCodexAndLocalMessages(codexMessages, localMessages, activeTurnId, chat.activeTurnId != null);
+			return resolveChatMessageTimeline({
+				activeTurnId,
+				chat,
+				codexMessages: normalizeCodexThreadMessages(await this.codex.readThread(chat.codexThreadId, { includeTurns: true }), chat.id),
+				localMessages
+			});
 		} catch {
 			return localMessagesWithoutStaleSteeredState(chat, localMessages);
 		}
@@ -26353,6 +26564,11 @@ var ServeServices = class {
 	async listModels() {
 		return normalizeModelRecords(await this.codex.listModels());
 	}
+	async listProjectSkills(projectId) {
+		const state = await this.store.load();
+		const project = this.requireProject(state, projectId);
+		return normalizeSkillRecords(await this.codex.listSkills([project.rootPath]));
+	}
 	async listSkills(chatId) {
 		const chat = await this.getChat(chatId);
 		return normalizeSkillRecords(await this.codex.listSkills([chat.worktreePath]));
@@ -26366,7 +26582,7 @@ var ServeServices = class {
 	async createCodexTurnOptions(input, chat) {
 		const attachments = await this.normalizeAttachmentItems(input.attachments, chat.id);
 		const files = await normalizeFileContextItems(input.files, chat.worktreePath);
-		const skills = await this.normalizeSkillContextItems(input.skills, chat.worktreePath);
+		const skills = await this.normalizeSkillContextItems(input.skills, chat);
 		if (!input.effort && !input.model && !input.serviceTier && attachments.length === 0 && files.length === 0 && skills.length === 0) return;
 		const options = {};
 		if (attachments.length > 0) options.attachments = attachments;
@@ -26410,13 +26626,22 @@ var ServeServices = class {
 			};
 		}));
 	}
-	async normalizeSkillContextItems(items, worktreePath) {
+	async normalizeSkillContextItems(items, chat) {
 		const normalized = normalizeTurnContextItems(items);
 		if (normalized.length === 0) return [];
-		const availableSkills = normalizeSkillRecords(await this.codex.listSkills([worktreePath]));
-		const skillsByPath = new Map(availableSkills.filter((skill) => skill.enabled).map((skill) => [skill.path, skill]));
+		const state = await this.store.load();
+		const project = this.requireProject(state, chat.projectId);
+		const projectSkillRoots = getProjectSkillRoots(state, project);
+		const skillListRoots = getSkillListRoots(chat, project);
+		const availableSkills = normalizeSkillRecords(await this.codex.listSkills(skillListRoots));
+		const skillsByPath = /* @__PURE__ */ new Map();
+		for (const skill of sortSkillsByRootPreference(availableSkills.filter((candidate) => candidate.enabled), skillListRoots)) {
+			skillsByPath.set(skill.path, skill);
+			const skillIdentity = normalizeProjectSkillPath(skill.path, projectSkillRoots);
+			if (!skillsByPath.has(skillIdentity)) skillsByPath.set(skillIdentity, skill);
+		}
 		return normalized.map((item) => {
-			const skill = skillsByPath.get(item.path);
+			const skill = skillsByPath.get(normalizeProjectSkillPath(item.path, projectSkillRoots)) ?? skillsByPath.get(item.path);
 			if (!skill) throw new Error(`Skill context path is not available: ${item.path}`);
 			return {
 				name: skill.name,
@@ -27055,6 +27280,7 @@ var ServeServices = class {
 			return;
 		}
 		if (method === "warning" || method === "guardianWarning" || method === "configWarning") {
+			if (isHiddenCodexWarning(method, params)) return;
 			await this.addRichEventMessage({
 				chatId,
 				eventData: params,
@@ -27465,17 +27691,26 @@ function extractCodexText(value) {
 	if (directText) return directText;
 	return extractCodexText(value.content);
 }
-function mergeCodexAndLocalMessages(codexMessages, localMessages, activeTurnId, protectActiveLocalTurn) {
+function resolveChatMessageTimeline({ activeTurnId, chat, codexMessages, localMessages }) {
+	if (codexMessages.length === 0) return localMessagesWithoutStaleSteeredState(chat, localMessages);
+	const localMessagesForCanonicalTranscript = isChatInActiveTurn(chat) ? localMessages : localMessagesWithoutStaleSteeredState(chat, localMessages);
+	const canonicalLocalTranscriptMatch = isChatInActiveTurn(chat) ? emptyCanonicalLocalTranscriptMatch() : findCanonicalLocalTranscriptMatch(codexMessages, localMessagesForCanonicalTranscript);
+	const deduplicatedCodexMessages = codexMessagesWithoutCanonicalLocalTranscript(codexMessages, canonicalLocalTranscriptMatch.codexMessageIndexes);
+	if (deduplicatedCodexMessages.length === 0) return localMessagesWithoutStaleSteeredState(chat, localMessages);
+	return mergeCodexAndLocalMessages(deduplicatedCodexMessages, localMessagesWithCanonicalStaleSteeredStateCleared(chat, localMessages, canonicalLocalTranscriptMatch), activeTurnId, chat.activeTurnId != null, canonicalLocalTranscriptMatch.localMessageCodexOrderMatches);
+}
+function mergeCodexAndLocalMessages(codexMessages, localMessages, activeTurnId, protectActiveLocalTurn, protectedLocalMessageCodexOrderMatches = /* @__PURE__ */ new Map()) {
 	if (codexMessages.length === 0) return localMessages;
 	const mergedCodexMessages = [...codexMessages];
 	const unmatchedCodexMessageIndexes = codexMessages.map((_, index) => index);
-	const localMessageCodexOrderMatches = /* @__PURE__ */ new Map();
+	const localMessageCodexOrderMatches = new Map(protectedLocalMessageCodexOrderMatches);
 	const steeredLocalMessageCounts = countSteeredLocalMessages(localMessages);
 	const fallbackTranscriptLocalMessageMatches = findFallbackTranscriptLocalMessageMatches(mergedCodexMessages, localMessages, activeTurnId, protectActiveLocalTurn ? findActiveLocalTurnStartIndex(localMessages) : localMessages.length);
 	const liveAssistantDeltaCodexOrderLimits = findLiveAssistantDeltaCodexOrderLimits(localMessages, mergedCodexMessages, steeredLocalMessageCounts, activeTurnId);
 	return assignMergedMessageSortKeys(mergedCodexMessages, localMessages.filter((message) => {
 		if (message.role === "event" || message.role === "error") return true;
 		if (message.eventType === "chat.message.queued") return true;
+		if (protectedLocalMessageCodexOrderMatches.has(message.id)) return true;
 		const fallbackTranscriptCodexIndex = fallbackTranscriptLocalMessageMatches.get(message.id);
 		if (fallbackTranscriptCodexIndex !== void 0 && unmatchedCodexMessageIndexes.includes(fallbackTranscriptCodexIndex)) {
 			const fallbackCodexMessage = mergedCodexMessages[fallbackTranscriptCodexIndex];
@@ -27524,10 +27759,98 @@ function mergeLocalMessageMetadataIntoCodexMessage(codexMessage, localMessage) {
 }
 function localMessagesWithoutStaleSteeredState(chat, localMessages) {
 	if (isChatInActiveTurn(chat)) return localMessages;
-	return localMessages.map((message) => message.eventType === "chat.message.steered" ? {
+	return localMessages.map((message) => localMessageWithoutStaleSteeredState(chat, message));
+}
+function localMessagesWithCanonicalStaleSteeredStateCleared(chat, localMessages, canonicalLocalTranscriptMatch) {
+	if (isChatInActiveTurn(chat) || canonicalLocalTranscriptMatch.localMessageCodexOrderMatches.size === 0) return localMessages;
+	return localMessages.map((message) => canonicalLocalTranscriptMatch.localMessageCodexOrderMatches.has(message.id) ? localMessageWithoutStaleSteeredState(chat, message) : message);
+}
+function localMessageWithoutStaleSteeredState(chat, message) {
+	if (isChatInActiveTurn(chat) || message.eventType !== "chat.message.steered") return message;
+	return {
 		...message,
 		eventType: void 0
-	} : message);
+	};
+}
+function emptyCanonicalLocalTranscriptMatch() {
+	return {
+		codexMessageIndexes: /* @__PURE__ */ new Set(),
+		localMessageCodexOrderMatches: /* @__PURE__ */ new Map()
+	};
+}
+function codexMessagesWithoutCanonicalLocalTranscript(codexMessages, duplicateCodexMessageIndexes) {
+	if (duplicateCodexMessageIndexes.size === 0) return codexMessages;
+	return codexMessages.filter((_, index) => !duplicateCodexMessageIndexes.has(index));
+}
+function findCanonicalLocalTranscriptMatch(codexMessages, localMessages) {
+	const matchedEntries = findCanonicalLocalTranscriptEntries(codexMessages, localMessages);
+	if (matchedEntries.length === 0) return emptyCanonicalLocalTranscriptMatch();
+	return {
+		codexMessageIndexes: new Set(matchedEntries.map((entry) => entry.codexIndex)),
+		localMessageCodexOrderMatches: new Map(matchedEntries.map((entry) => [entry.localId, entry.message.codexOrder ?? entry.codexIndex]))
+	};
+}
+function findCanonicalLocalTranscriptEntries(codexMessages, localMessages) {
+	const minimumCanonicalTranscriptLength = 4;
+	const matchedCodexEntries = [];
+	let nextLocalIndex = 0;
+	for (const [codexIndex, codexMessage] of codexMessages.entries()) {
+		if (!isTranscriptMessage(codexMessage)) continue;
+		const matchedLocalIndex = findNextCanonicalLocalTranscriptIndex(localMessages, nextLocalIndex, codexMessage);
+		if (matchedLocalIndex === -1) break;
+		const matchedLocalMessage = localMessages[matchedLocalIndex];
+		if (!matchedLocalMessage) break;
+		matchedCodexEntries.push({
+			codexIndex,
+			localId: matchedLocalMessage.id,
+			message: codexMessage
+		});
+		nextLocalIndex = matchedLocalIndex + 1;
+	}
+	const matchedMessages = matchedCodexEntries.map((entry) => entry.message);
+	const hasNewerCodexTranscriptMessage = hasCodexTranscriptMessageAfterMatchedPrefix(codexMessages, matchedCodexEntries);
+	const hasSubstantialCanonicalTranscript = matchedMessages.length >= minimumCanonicalTranscriptLength && matchedMessages.some((message) => message.role === "user") && matchedMessages.filter((message) => message.role === "assistant").length >= 2;
+	const hasOpenUserBoundaryBeforeNewerCodexTranscript = hasNewerCodexTranscriptMessage && matchedMessages[0]?.role === "user" && matchedMessages.some((message) => message.role === "assistant") && matchedMessages[matchedMessages.length - 1]?.role === "user";
+	const hasCompletedExchangeBeforeSameTurnCodexAssistant = matchedMessages[0]?.role === "user" && matchedMessages.some((message) => message.role === "assistant") && matchedMessages[matchedMessages.length - 1]?.role === "assistant" && hasSameTurnAssistantMessageAfterMatchedPrefix(codexMessages, matchedCodexEntries);
+	if (!hasSubstantialCanonicalTranscript && !hasOpenUserBoundaryBeforeNewerCodexTranscript && !hasCompletedExchangeBeforeSameTurnCodexAssistant) return [];
+	if (new Set(matchedMessages.map((message) => message.codexTurnId).filter(Boolean)).size > 1 && !hasOpenUserBoundaryBeforeNewerCodexTranscript) return [];
+	return matchedCodexEntries;
+}
+function findNextCanonicalLocalTranscriptIndex(localMessages, startIndex, codexMessage) {
+	for (let localIndex = startIndex; localIndex < localMessages.length; localIndex += 1) {
+		const localMessage = localMessages[localIndex];
+		if (!isTranscriptMessage(localMessage)) {
+			if (isSkippableCanonicalLocalTimelineMessage(localMessage)) continue;
+			return -1;
+		}
+		return messageFingerprint(localMessage) === messageFingerprint(codexMessage) && isLocalMessageAtOrBeforeCodexMessage(localMessage, codexMessage) ? localIndex : -1;
+	}
+	return -1;
+}
+function isSkippableCanonicalLocalTimelineMessage(message) {
+	return message.role === "event" || message.role === "error";
+}
+function hasCodexTranscriptMessageAfterMatchedPrefix(codexMessages, matchedEntries) {
+	const lastMatchedEntry = matchedEntries[matchedEntries.length - 1];
+	if (!lastMatchedEntry) return false;
+	return codexMessages.some((message, index) => index > lastMatchedEntry.codexIndex && isTranscriptMessage(message));
+}
+function hasSameTurnAssistantMessageAfterMatchedPrefix(codexMessages, matchedEntries) {
+	const lastMatchedEntry = matchedEntries[matchedEntries.length - 1];
+	if (!lastMatchedEntry) return false;
+	const lastMatchedMessage = codexMessages[lastMatchedEntry.codexIndex];
+	if (!lastMatchedMessage?.codexTurnId) return false;
+	return codexMessages.some((message, index) => index > lastMatchedEntry.codexIndex && message.codexTurnId === lastMatchedMessage.codexTurnId && message.role === "assistant" && isTranscriptMessage(message));
+}
+function isTranscriptMessage(message) {
+	return (message.role === "assistant" || message.role === "user") && !isQueuedMessage(message) && !isPendingSteeredMessage(message);
+}
+function isLocalMessageAtOrBeforeCodexMessage(localMessage, codexMessage) {
+	if (codexMessage.hasFallbackTimestamp) return true;
+	const codexTime = Date.parse(codexMessage.createdAt);
+	const localTime = Date.parse(localMessage.createdAt);
+	if (Number.isFinite(codexTime) && Number.isFinite(localTime)) return localTime <= codexTime;
+	return localMessage.createdAt <= codexMessage.createdAt;
 }
 function insertRecordAtIndex(records, record, index) {
 	if (index >= records.length) return [...records, record];
@@ -27554,12 +27877,22 @@ function assignMergedMessageSortKeys(codexMessages, localMessages, allLocalMessa
 	})];
 }
 function getLocalMessageMergeSortBucket(message, index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId) {
-	if (isPendingSteeredMessage(message)) return orderedCodexMessages.length * 2 + 2;
-	if (isQueuedMessage(message)) return orderedCodexMessages.length * 2 + 3;
+	if (isPendingSteeredMessage(message)) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 2);
+	if (isQueuedMessage(message)) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 3);
+	const matchedCodexOrder = localMessageCodexOrderMatches.get(message.id);
+	if (matchedCodexOrder !== void 0 && isTranscriptMessage(message)) return matchedCodexOrder * 2;
 	if (isLocalTimelineEvent(message)) return getLocalTimelineEventMergeSortBucket(index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId);
 	if (isLiveAssistantDeltaMessage(message)) return getLiveAssistantDeltaMergeSortBucket(message, index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId);
 	return getStandardLocalMessageMergeSortBucket(message, orderedCodexMessages, index, localMessages, localMessageCodexOrderMatches);
 }
+function getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, offset) {
+	return (orderedCodexMessages.reduce((maxOrder, message, index) => Math.max(maxOrder, message.codexOrder ?? index), -1) + 1) * 2 + offset;
+}
+function getBeforeCodexMessageMergeSortBucket(orderedCodexMessages, insertionIndex) {
+	const codexMessage = orderedCodexMessages[insertionIndex];
+	if (!codexMessage) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 1);
+	return (codexMessage.codexOrder ?? insertionIndex) * 2 - 1;
+}
 function getLocalTimelineEventMergeSortBucket(index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId) {
 	const earlierLocalBoundaryBucket = localMessages.slice(0, index).map((message, index) => ({
 		index,
@@ -27575,7 +27908,7 @@ function getLocalTimelineEventMergeSortBucket(index, localMessages, orderedCodex
 		return earlierLocalBoundaryBucket + .5;
 	}
 	if (earlierLocalBoundaryBucket !== void 0) return earlierLocalBoundaryBucket + .5;
-	if (laterLocalBoundaryBucket === void 0) return orderedCodexMessages.length * 2 + 1;
+	if (laterLocalBoundaryBucket === void 0) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 1);
 	return laterLocalBoundaryBucket - .5;
 }
 function getLocalTimelineEventBoundaryMergeSortBucket(message, index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId) {
@@ -27584,8 +27917,8 @@ function getLocalTimelineEventBoundaryMergeSortBucket(message, index, localMessa
 		const boundaryBucket = getLocalUserBoundaryMergeSortBucket(message, index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches);
 		if (boundaryBucket !== null) return boundaryBucket;
 	}
-	if (isPendingSteeredMessage(message)) return orderedCodexMessages.length * 2 + 2;
-	if (isQueuedMessage(message)) return orderedCodexMessages.length * 2 + 3;
+	if (isPendingSteeredMessage(message)) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 2);
+	if (isQueuedMessage(message)) return getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 3);
 	if (!isLiveAssistantDeltaMessage(message)) return null;
 	return getMergedLiveAssistantDeltaMergeSortBucket(message, orderedCodexMessages, localMessageCodexOrderMatches) ?? getLiveAssistantDeltaMergeSortBucket(message, index, localMessages, orderedCodexMessages, localMessageCodexOrderMatches, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId);
 }
@@ -27593,9 +27926,9 @@ function getStandardLocalMessageMergeSortBucket(message, orderedCodexMessages, i
 	const insertionIndex = orderedCodexMessages.findIndex((codexMessage) => codexMessage.createdAt > message.createdAt);
 	if (insertionIndex !== -1 && orderedCodexMessages[insertionIndex]?.hasFallbackTimestamp) {
 		const nextTrustedInsertionIndex = orderedCodexMessages.findIndex((codexMessage, index) => index > insertionIndex && !codexMessage.hasFallbackTimestamp && codexMessage.createdAt > message.createdAt);
-		return applyEarlierLocalCodexBoundary(nextTrustedInsertionIndex === -1 ? orderedCodexMessages.length * 2 + 1 : nextTrustedInsertionIndex * 2 - 1, index, localMessages, localMessageCodexOrderMatches);
+		return applyEarlierLocalCodexBoundary(nextTrustedInsertionIndex === -1 ? getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 1) : getBeforeCodexMessageMergeSortBucket(orderedCodexMessages, nextTrustedInsertionIndex), index, localMessages, localMessageCodexOrderMatches);
 	}
-	return applyEarlierLocalCodexBoundary(insertionIndex === -1 ? orderedCodexMessages.length * 2 + 1 : insertionIndex * 2 - 1, index, localMessages, localMessageCodexOrderMatches);
+	return applyEarlierLocalCodexBoundary(insertionIndex === -1 ? getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 1) : getBeforeCodexMessageMergeSortBucket(orderedCodexMessages, insertionIndex), index, localMessages, localMessageCodexOrderMatches);
 }
 function applyEarlierLocalCodexBoundary(bucket, index, localMessages, localMessageCodexOrderMatches) {
 	if (index === void 0 || !localMessages || !localMessageCodexOrderMatches) return bucket;
@@ -27626,9 +27959,9 @@ function getLiveAssistantDeltaMergeSortBucket(message, index, localMessages, ord
 	const boundaryInsertionIndex = findLiveAssistantDeltaBoundaryInsertionIndex(message, index, localMessages, orderedCodexMessages, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId);
 	if (boundaryInsertionIndex === null) {
 		const earlierMatchedCodexOrder = getEarlierLocalCodexOrder(index, localMessages, localMessageCodexOrderMatches);
-		return earlierMatchedCodexOrder === void 0 ? orderedCodexMessages.length * 2 + 1 : earlierMatchedCodexOrder * 2 + .5;
+		return earlierMatchedCodexOrder === void 0 ? getAfterCodexMessagesMergeSortBucket(orderedCodexMessages, 1) : earlierMatchedCodexOrder * 2 + .5;
 	}
-	return applyEarlierLocalCodexBoundary(boundaryInsertionIndex * 2 - 1, index, localMessages, localMessageCodexOrderMatches);
+	return applyEarlierLocalCodexBoundary(getBeforeCodexMessageMergeSortBucket(orderedCodexMessages, boundaryInsertionIndex), index, localMessages, localMessageCodexOrderMatches);
 }
 function findLiveAssistantDeltaBoundaryInsertionIndex(message, index, localMessages, orderedCodexMessages, liveAssistantDeltaCodexOrderLimits, steeredLocalMessageCounts, activeTurnId) {
 	if (!isLiveAssistantDeltaMessage(message)) return null;
@@ -28184,6 +28517,40 @@ function normalizeSkillRecords(value) {
 		};
 	}).filter((skill) => Boolean(skill));
 }
+function getProjectSkillRoots(state, project) {
+	return Array.from(new Set([project.rootPath, ...state.chats.filter((chat) => chat.projectId === project.id).map((chat) => chat.worktreePath)])).sort((left, right) => right.length - left.length);
+}
+function getSkillListRoots(chat, project) {
+	return Array.from(new Set([chat.worktreePath, project.rootPath]));
+}
+function sortSkillsByRootPreference(skills, roots) {
+	return [...skills].sort((left, right) => getPathRootIndex(left.path, roots) - getPathRootIndex(right.path, roots));
+}
+function getPathRootIndex(path, roots) {
+	if (!isAbsolute(path)) return roots.length;
+	const rootIndex = roots.findIndex((root) => isPathInside(root, path));
+	return rootIndex === -1 ? roots.length : rootIndex;
+}
+function normalizeRecentProjectSkillRecordPaths(records, projectSkillRoots) {
+	const seenSkillPaths = /* @__PURE__ */ new Set();
+	return records.map((record) => ({
+		...record,
+		path: normalizeProjectSkillPath(record.path, projectSkillRoots)
+	})).filter((record) => {
+		if (seenSkillPaths.has(record.path)) return false;
+		seenSkillPaths.add(record.path);
+		return true;
+	});
+}
+function normalizeProjectSkillPath(skillPath, projectSkillRoots) {
+	const trimmedSkillPath = skillPath.trim();
+	if (!isAbsolute(trimmedSkillPath)) return trimmedSkillPath;
+	for (const root of projectSkillRoots) {
+		const relativeSkillPath = relative(root, trimmedSkillPath);
+		if (relativeSkillPath && !relativeSkillPath.startsWith(`..${sep}`) && relativeSkillPath !== ".." && !isAbsolute(relativeSkillPath)) return relativeSkillPath.split(sep).join("/");
+	}
+	return trimmedSkillPath;
+}
 function normalizeFileRecords(value) {
 	return (getRecordArray(value, "files") ?? []).map((file) => {
 		const matchType = getRecordString(file, "match_type");
@@ -28345,6 +28712,16 @@ function sanitizeCodexEventParams(method, params) {
 	}
 	return params;
 }
+const hiddenCodexWarningMessages = new Set(["Automatic approval review approved"]);
+function isHiddenCodexWarning(method, params) {
+	if (method !== "warning" && method !== "guardianWarning" && method !== "configWarning") return false;
+	const object = getParamObject(params);
+	return [
+		summarizeCodexEvent(method, params),
+		typeof object?.message === "string" ? object.message : null,
+		typeof object?.summary === "string" ? object.summary : null
+	].some((candidate) => typeof candidate === "string" && hiddenCodexWarningMessages.has(candidate.trim()));
+}
 function sanitizeCodexEventItem(item) {
 	const itemType = getRecordString(item, "type");
 	if (itemType === "commandExecution") return stripRecordKey(item, "aggregatedOutput");
@@ -28548,6 +28925,7 @@ const deleteWorktreeSchema = worktreeSchema.extend({
 	force: boolean().optional(),
 	keepBranch: boolean().optional()
 });
+const recentProjectSkillSchema = object({ path: string().min(1, "Skill path is required") });
 const sendMessageSchema = object({
 	text: string().min(1, "Message text is required"),
 	attachments: array(attachmentSchema).optional(),
@@ -28734,6 +29112,28 @@ const rpcRoutes = new Hono().get("/health", async (c) => {
 	} catch (error) {
 		return handleApiError(c, error);
 	}
+}).get("/projects/:projectId/skills", async (c) => {
+	try {
+		const skills = await getServeServices().listProjectSkills(c.req.param("projectId"));
+		return c.json({ skills }, 200);
+	} catch (error) {
+		return handleApiError(c, error);
+	}
+}).get("/projects/:projectId/recent-skills", async (c) => {
+	try {
+		const recentSkills = await getServeServices().listRecentProjectSkills(c.req.param("projectId"));
+		return c.json({ recentSkills }, 200);
+	} catch (error) {
+		return handleApiError(c, error);
+	}
+}).post("/projects/:projectId/recent-skills", jsonBody(recentProjectSkillSchema), async (c) => {
+	try {
+		const body = c.req.valid("json");
+		const recentSkills = await getServeServices().rememberRecentProjectSkill(c.req.param("projectId"), body.path);
+		return c.json({ recentSkills }, 200);
+	} catch (error) {
+		return handleApiError(c, error);
+	}
 }).get("/projects/:projectId/github/checkout-targets", async (c) => {
 	try {
 		const github = await getServeServices().listProjectGitHubCheckoutTargets(c.req.param("projectId"));
@@ -29144,4 +29544,4 @@ function createApp() {
 //#endregion
 export { EventHub as a, getServeServices as i, rpcRoutes as n, createSseResponse as o, ServeServices as r, parseLastEventId as s, createApp as t };
 
-//# sourceMappingURL=app-BLBOjh4e.mjs.map
+//# sourceMappingURL=app-DS_9Jsep.mjs.map