@rexvane/piweb 0.3.20 → 0.3.22

package/src/lib/thinking-level.ts

@@ -0,0 +1,39 @@
+/**
+ * 思考档位的纯函数，客户端与服务端共用（不引入 pi-ai）。规则与 pi-ai 的 clampThinkingLevel、
+ * pi 的 createAgentSession 一致；tests/thinking-level.test.ts 里逐项和 pi-ai 对照。
+ */
+
+/** pi-ai 的 EXTENDED_THINKING_LEVELS：从低到高 */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+/** pi 的 DEFAULT_THINKING_LEVEL：设置里没有默认档位、模型也没有覆盖时用它 */
+export const DEFAULT_THINKING_LEVEL = "medium";
+
+/**
+ * 把档位钳到模型支持的范围：支持就原样返回；否则先向更高的档位找，再向更低的档位找，都没有就取第一个支持的。
+ */
+export function clampThinkingLevelTo(supported: readonly string[], level: string): string {
+	if (supported.includes(level)) return level;
+	const index = THINKING_LEVELS.indexOf(level);
+	if (index === -1) return supported[0] ?? "off";
+	for (let i = index; i < THINKING_LEVELS.length; i += 1) {
+		if (supported.includes(THINKING_LEVELS[i])) return THINKING_LEVELS[i];
+	}
+	for (let i = index - 1; i >= 0; i -= 1) {
+		if (supported.includes(THINKING_LEVELS[i])) return THINKING_LEVELS[i];
+	}
+	return supported[0] ?? "off";
+}
+
+/**
+ * 新会话实际会用的档位（SDK createAgentSession 的规则）：用户显式选过就用它；否则依次取该模型的每模型覆盖、
+ * 设置里的默认档位、DEFAULT_THINKING_LEVEL；最后按模型能力钳制。
+ */
+export function newSessionThinkingLevel(input: {
+	supported: readonly string[];
+	requested?: string;
+	modelOverride?: string;
+	defaultLevel?: string;
+}): string {
+	return clampThinkingLevelTo(input.supported, input.requested || input.modelOverride || input.defaultLevel || DEFAULT_THINKING_LEVEL);
+}

package/src/lib/trajectory.ts

@@ -1,12 +1,17 @@
 /**
  * 轨迹账本：对齐 dsh ui-trajectory 的 cell 模型（system/user/message/tool/compacted）。
  * 活跃会话由 pi 事件实时驱动；冷会话从 JSONL 条目离线重建。
- * pi 无耗时字段——TTFT/decode 由服务端自测，仅活跃会话有值。
+ * pi 持久化 LLM / 工具 durationMs；TTFT/decode 由服务端自测，仅活跃会话有值。
  */
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { TrajEntry, TrajTokens } from "./types";
 import { sanitizeToolOutput } from "./text-sanitize";
 
+/** 只恢复 SDK 已记录的耗时，不从相邻消息时间戳推算。 */
+function storedDuration(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
 export function toTrajTokens(u: any): TrajTokens | undefined {
 	if (!u || typeof u !== "object") return undefined;
 	const t: TrajTokens = {};
@@ -88,6 +93,8 @@ export class TrajLedger {
 						e.encodingLoss = result.encodingLoss || e.encodingLoss;
 						e.isError = m.isError === true;
 						e.tokens = toTrajTokens(m.usage) ?? e.tokens;
+						const durationMs = storedDuration(m.durationMs);
+						if (durationMs !== undefined) e.timing = { ...e.timing, durationMs };
 						this.touch(e);
 					}
 				}
@@ -96,7 +103,7 @@ export class TrajLedger {
 			case "message_update": {
 				const e: any = evt.assistantMessageEvent;
 				if (!e) break;
-				if ((e.type === "text_delta" || e.type === "thinking_delta") && this.streamingStart) {
+				if ((e.type === "text_delta" || e.type === "thinking_delta" || e.type === "toolcall_delta") && e.delta?.length > 0 && this.streamingStart) {
 					if (this.streamingStart.firstToken === undefined) {
 						this.streamingStart.firstToken = now;
 						const last = this.entries[this.entries.length - 1];
@@ -127,6 +134,8 @@ export class TrajLedger {
 							durationMs: now - this.streamingStart.t0,
 						};
 					}
+					const durationMs = storedDuration(m.durationMs);
+					if (durationMs !== undefined) e.timing = { ...e.timing, durationMs };
 					e.tokens = toTrajTokens(m.usage);
 					e.thinking = textOf(
 						(m.content ?? []).filter((c: any) => c.type === "thinking").map((c: any) => c.thinking),
@@ -194,7 +203,8 @@ export class TrajLedger {
 					e.encodingLoss = result.encodingLoss || e.encodingLoss;
 					e.isError = evt.isError === true;
 					const startedAt = this.toolStart.get(evt.toolCallId);
-					if (startedAt !== undefined) e.timing = { ...(e.timing ?? {}), durationMs: now - startedAt };
+					const durationMs = storedDuration((evt as any).durationMs) ?? (startedAt !== undefined ? now - startedAt : undefined);
+					if (durationMs !== undefined) e.timing = { ...(e.timing ?? {}), durationMs };
 					this.touch(e);
 				}
 				this.toolStart.delete(evt.toolCallId);
@@ -236,6 +246,7 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 			} else if (m.role === "assistant") {
 				const thinking = textOf((m.content ?? []).filter((c: any) => c.type === "thinking"));
 				const text = textOf((m.content ?? []).filter((c: any) => c.type === "text"));
+				const durationMs = storedDuration(m.durationMs);
 				out.push({
 					seq: seq++,
 					kind: "message",
@@ -244,6 +255,7 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 					detail: text,
 					thinking: thinking || undefined,
 					tokens: toTrajTokens(m.usage),
+					...(durationMs === undefined ? {} : { timing: { durationMs } }),
 					isError: m.stopReason === "error" || undefined,
 				});
 				for (const c of m.content ?? []) {
@@ -269,6 +281,8 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 					target.encodingLoss = result.encodingLoss || target.encodingLoss;
 					target.isError = m.isError === true || undefined;
 					target.tokens = toTrajTokens(m.usage) ?? target.tokens;
+					const durationMs = storedDuration(m.durationMs);
+					if (durationMs !== undefined) target.timing = { durationMs };
 				}
 			}
 		} else if (raw.type === "compaction") {

package/src/lib/types.ts

@@ -116,6 +116,8 @@ export type WebEvent =
 	| { type: "traj"; entry: TrajEntry; ts: number }
 	| { type: "name"; name: string; ts: number }
 	| { type: "tools"; active: string[]; all: string[]; toolPreset?: ToolPreset; customActiveTools?: string[] | null; ts: number }
+	/** 上下文分项变了（会话启动、工具 / 资源重载、压缩之后）：替换快照里的 contextBreakdown */
+	| { type: "context_breakdown"; breakdown: ContextBreakdown; ts: number }
 	| {
 			/** 资源（扩展/技能/模板/命令）重载后的新清单；前端据此刷新 / 菜单与设置面板 */
 			type: "resources";
@@ -143,8 +145,10 @@ export type WebEvent =
 	  }
 	| { type: "extension_ui_resolved"; id: string; ts: number }
 	| { type: "error"; message: string; ts: number }
-	/** 自动重试：流程内通知，界面聚合成一条「重试 n/max」，不作为错误条目累积 */
+	/** 自动重试:流程内通知,界面聚合成一条「重试 n/max」,不作为错误条目累积 */
 	| { type: "retry"; attempt: number; maxAttempts: number; message: string; ts: number }
+	/** 重试区间结束(SDK auto_retry_end):收掉「重试 n/max」那一行;真失败由后续 error 消息表达 */
+	| { type: "retry_end"; attempt: number; ts: number }
 	/** 项目生长：提交了一个 commit（pi 的一轮 / 用户两轮之间的修改 / 工作区基线） */
 	| { type: "growth"; round: GrowthRound; ts: number }
 	| { type: "growth_error"; message: string | null; ts: number }
@@ -164,6 +168,11 @@ export interface WebStats {
 	ttftSteps: number;
 	decodeMs: number;
 	decodeTokens: number;
+	/** 有持久化耗时的消息 / 工具数量；旧历史缺数据时显示覆盖范围。 */
+	llmTimedSteps?: number;
+	toolTimedCalls?: number;
+	/** 生成速度实际测到的回复数，不代表整个历史。 */
+	decodeSteps?: number;
 }
 
 // ---------- 项目生长（每轮一个 git commit） ----------
@@ -234,6 +243,8 @@ export interface ContextResource {
  * 这里只放服务端才能拿到的部分。
  */
 export interface ContextBreakdown {
+	/** 当前投影中实际文本的字符数；不将估算 token 按比例分摊。 */
+	characters?: { systemPrompt: number; systemTools: number; customTools: number; memory: number; skills: number; compacted: number };
 	/** SDK 内建 system prompt 正文（不含 memory/skills/tools 段）的估算 token */
 	systemPrompt: number;
 	/** 内建工具（SDK 自带 bash/read/edit 等）定义的估算 token */
@@ -248,6 +259,11 @@ export interface ContextBreakdown {
 	compacted: number;
 	/** auto-compact 预留（compaction.reserveTokens 设置值；未启用为 0） */
 	autoCompactBuffer: number;
+	/**
+	 * 会话还没启动（只浏览历史不冷启动 agent）：systemPrompt / systemTools / customTools 拿不到、为 0，
+	 * 其余几项照常统计。前端据此提示并提供「现在统计」（prepare 启动会话）。
+	 */
+	cold?: boolean;
 }
 
 /** SSE 连接建立时先发的完整快照 */
@@ -331,6 +347,8 @@ export interface AgentCommand {
 	instructions?: string;
 	provider?: string;
 	modelId?: string;
+	/** setModel：新会话页选的模型，思考档位按新会话的规则定（不沿用会话原来的档位） */
+	fresh?: boolean;
 	level?: string;
 	preset?: ToolPreset;
 	entryId?: string;

package/src/lib/update/startup-check.ts

@@ -0,0 +1,117 @@
+/**
+ * 启动时检查一次更新：PiWeb 和 pi 各查一次，结果留在内存里给设置页和右下角提示条用，
+ * 有新版本时在终端打一行。离线、registry 不通都不吭声——设置里还能手动检查。
+ *
+ * 状态挂 globalThis：instrumentation 和路由是不同的 bundle，模块级变量不共享（同 remote/supervisor）。
+ * 每次服务启动换一个 startId，页面据此做到「每次启动提醒一次」。
+ * 手动检查、更新成功后改写这份缓存：刷新页面不会又显示「更新到 vX」。
+ * PI_WEB_UPDATE_CHECK=0 关掉启动检查（不联网），设置里手动检查不受影响。
+ */
+import { randomUUID } from "node:crypto";
+import { checkForUpdate, type UpdateCheck, type UpdateTarget } from "../update-service";
+
+/** 一项的结果：检查结果（更新过就带上 updatedTo），或检查失败的原因 */
+export type StartupResult = (UpdateCheck & { updatedTo?: string }) | { error: string };
+
+export interface StartupUpdates {
+	/** 本次服务启动的标识；关掉启动检查时为 null */
+	startId: string | null;
+	results: Partial<Record<UpdateTarget, StartupResult>>;
+}
+
+interface StartupState {
+	startId: string;
+	results: Partial<Record<UpdateTarget, StartupResult>>;
+	pending: Promise<void> | null;
+	started: boolean;
+}
+
+interface StartupOptions {
+	check?: (target: UpdateTarget) => Promise<UpdateCheck>;
+	log?: (line: string) => void;
+	env?: Record<string, string | undefined>;
+}
+
+const STATE_KEY = "piweb.update.startup";
+const TARGETS: readonly UpdateTarget[] = ["piweb", "pi"];
+const LABEL: Record<UpdateTarget, string> = { piweb: "PiWeb", pi: "Pi" };
+
+function state(): StartupState {
+	const store = globalThis as Record<PropertyKey, unknown>;
+	const key = Symbol.for(STATE_KEY);
+	const existing = store[key] as StartupState | undefined;
+	if (existing) return existing;
+	const created: StartupState = { startId: randomUUID(), results: {}, pending: null, started: false };
+	store[key] = created;
+	return created;
+}
+
+export function startupCheckEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return env.PI_WEB_UPDATE_CHECK !== "0";
+}
+
+/** 终端里那一行；没有新版本时为 null */
+export function updateNoticeLine(results: StartupUpdates["results"]): string | null {
+	const parts: string[] = [];
+	let manual: string | undefined;
+	for (const target of TARGETS) {
+		const result = results[target];
+		if (!result || "error" in result || !result.canUpdate) continue;
+		// Git 检出版本号没变、只是 main 上有新提交时，写提交数而不是「0.3.20 → 0.3.20」
+		parts.push(result.latest === result.current && result.behind ? `${LABEL[target]}（main 新增 ${result.behind} 个提交）` : `${LABEL[target]} ${result.current} → ${result.latest}`);
+		if (!result.selfUpdate && result.command) manual = result.command;
+	}
+	if (!parts.length) return null;
+	const line = `[更新] 有新版本：${parts.join("、")}。打开 设置 → 通用 点「更新」`;
+	return manual ? `${line}；PiWeb 要先停掉 piweb 再运行：${manual}` : line;
+}
+
+/**
+ * 启动检查（只跑一次）；返回检查完之后的状态快照。关掉时返回 null，不联网。
+ * instrumentation 在启动时调它，GET /api/update 也调它（页面先到时由页面触发，结果一样只查一次）。
+ */
+export async function ensureStartupCheck({ check = checkForUpdate, log = console.log, env = process.env }: StartupOptions = {}): Promise<StartupUpdates | null> {
+	if (!startupCheckEnabled(env)) return null;
+	const current = state();
+	if (!current.started) {
+		current.started = true;
+		current.pending = (async () => {
+			await Promise.all(TARGETS.map(async (target) => {
+				try {
+					const result = await check(target);
+					// 检查期间已经手动更新过的项不覆盖
+					if (!current.results[target]) current.results[target] = result;
+				} catch (error) {
+					if (!current.results[target]) current.results[target] = { error: error instanceof Error ? error.message : String(error) };
+				}
+			}));
+			const line = updateNoticeLine(current.results);
+			if (line) log(line);
+		})();
+	}
+	await current.pending;
+	return snapshot();
+}
+
+function snapshot(): StartupUpdates {
+	const current = state();
+	return { startId: current.startId, results: { ...current.results } };
+}
+
+/** 手动检查的结果覆盖缓存 */
+export function recordCheck(target: UpdateTarget, check: UpdateCheck): void {
+	state().results[target] = check;
+}
+
+/** 更新成功：记下装好的版本，页面刷新后显示「已更新，重启生效」而不是又让人更新一次 */
+export function markUpdated(target: UpdateTarget, version: string): void {
+	const current = state();
+	const previous = current.results[target];
+	const base = previous && !("error" in previous) ? previous : { current: "", latest: version, canUpdate: false, selfUpdate: true };
+	current.results[target] = { ...base, latest: version || base.latest, canUpdate: false, updatedTo: version || base.latest };
+}
+
+/** 仅供测试：清掉挂在 globalThis 上的状态 */
+export function resetStartupCheck(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(STATE_KEY)];
+}

package/src/lib/update-service.ts

@@ -5,7 +5,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import { installPiUpdate, PI_PACKAGE, prepareRelease } from "../../scripts/release.mjs";
+import { installPiUpdate, PI_AI_PACKAGE, PI_PACKAGE, prepareRelease } from "../../scripts/release.mjs";
 import { assertInstallation, readProductionBuild } from "../../scripts/build-output.mjs";
 import { runCommand } from "../../scripts/process-runner.mjs";
 import { isNewer } from "./semver";
@@ -153,14 +153,34 @@ export function createUpdateService({ root = APP_ROOT, run = runCommand, version
 		return { ...readProductionBuild(installation, ".next"), version, needsRestart: true };
 	}
 
+	/**
+	 * 只换 npm 成品包里的 pi 依赖：成品包没有 devDependencies，跑不了 typecheck / 构建，也不需要——
+	 * pi 两个包都在 serverExternalPackages 里，运行时从这里的 node_modules 加载，重启即用上新版。
+	 * Windows 也能做：运行中的服务没加载 pi 的原生模块，pi 目录也不是服务的工作目录，不会 EBUSY。
+	 * 图标不用同步：成品包自带 public/provider-icons，清单也和 pi 版本无关。
+	 */
+	async function installPiIntoPackage(installation: string, assertIdle: () => Promise<void>): Promise<UpdateResult> {
+		await assertIdle();
+		await run("npm", ["install", "--save-exact", `${PI_PACKAGE}@latest`, `${PI_AI_PACKAGE}@latest`, "--omit=dev", "--no-audit", "--no-fund"], {
+			cwd: installation, env: commandEnv, timeoutMs: 600_000,
+		});
+		await assertIdle();
+		assertInstallation(installation);
+		const version = await readPackageVersion(path.join(installation, "node_modules", PI_PACKAGE, "package.json"));
+		return { ...readProductionBuild(installation, ".next"), version, needsRestart: true };
+	}
+
 	async function runUpdate(target: UpdateTarget, { assertIdle = async () => {} }: { assertIdle?: () => Promise<void> } = {}): Promise<UpdateResult> {
 		assertTarget(target);
 		if (updateRunning) throw new UpdateBusyError("an update is already running");
 		updateRunning = true;
 		try {
 			const installation = await checkedRoot();
-			// npm 安装：装发布好的成品即可——不需要 Git，也不需要本地构建（成品包自带 .next）。
-			if (target === "piweb" && isNpmInstall(installation)) return await installFromRegistry(installation, assertIdle);
+			// npm 安装：装发布好的成品即可——不需要 Git，也不需要本地构建（成品包自带 .next）；
+			// 单独更新 pi 只换依赖，同样不重建。
+			if (isNpmInstall(installation)) {
+				return target === "piweb" ? await installFromRegistry(installation, assertIdle) : await installPiIntoPackage(installation, assertIdle);
+			}
 			let version = "";
 			const release = await prepareRelease({
 				root: installation, env, run,

package/src/lib/workspace-index.ts

@@ -0,0 +1,270 @@
+/**
+ * @ 引用的候选与匹配（纯逻辑，便于单测）：照搬 pi 终端的 `@` 补全
+ * （pi-tui `CombinedAutocompleteProvider.getFuzzyFileSuggestions` + `extractAtPrefix`），
+ * 同一个 `@que` 在终端和网页里给出同一批、同一顺序的候选。
+ *
+ * pi 的做法：`@` 后的文字按最后一个 `/` 拆成「目录 + 查询」（目录存在才算），
+ * 在该目录下用 fd 过滤（查询当正则、smart case，默认只匹配文件名，带 `/` 时匹配整条路径），
+ * 再用 scoreEntry 打分（文件名全等 100 / 前缀 80 / 包含 50 / 路径包含 30，目录 +10），
+ * 按分数、层级、路径长度、字典序排，取前 20。
+ *
+ * 有意的差别（tests/mention-parity.test.ts 里逐条对照，差别也写在那里）：
+ * - 候选来自服务端给的工作区清单（git 可见文件 + 推导出的文件夹），不现场跑 fd；
+ *   pi 每次 fd 只取前 100 条再打分，这里对整份清单打分——结果是「fd 不截断时 pi 会给的」，而且稳定。
+ * - 不支持 `~/`、绝对路径和跳出工作区的 `../`：引用只针对当前工作区。
+ * - fd 的 `--full-path` 匹配绝对路径，这里匹配相对路径（只差在工作区自身路径恰好命中的极端情况）。
+ */
+
+export interface PathCandidate {
+	/** 工作区根的相对路径（"/" 分隔），目录不带尾斜杠 */
+	path: string;
+	dir: boolean;
+}
+
+/** 显示用：目录带尾斜杠 */
+export function candidateText(candidate: PathCandidate): string {
+	return candidate.dir ? `${candidate.path}/` : candidate.path;
+}
+
+/** 文件路径 → 全部父目录（去重、不含 "."） */
+export function dirsOfPaths(files: string[]): string[] {
+	const dirs = new Set<string>();
+	for (const file of files) {
+		const parts = file.split("/");
+		for (let i = 1; i < parts.length; i += 1) dirs.add(parts.slice(0, i).join("/"));
+	}
+	return [...dirs];
+}
+
+export function buildCandidates(files: string[], dirs: string[]): PathCandidate[] {
+	const out: PathCandidate[] = [];
+	for (const dir of dirs) out.push({ path: dir, dir: true });
+	for (const file of files) out.push({ path: file, dir: false });
+	return out;
+}
+
+// ---------- 匹配与排序（pi-tui autocomplete.js） ----------
+
+/** pi 一次最多列 20 条 */
+export const MENTION_LIMIT = 20;
+
+export interface MentionSuggestion {
+	candidate: PathCandidate;
+	/** 文件名，目录带尾斜杠（pi 的 label） */
+	label: string;
+	/** 路径（pi 的 description）：按用户打的目录前缀显示，如 `./src/lib` */
+	description: string;
+}
+
+function toDisplayPath(value: string): string {
+	return value.replace(/\\/g, "/");
+}
+
+function baseName(path: string): string {
+	const trimmed = path.replace(/\/+$/, "");
+	return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+
+function escapeRegex(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** pi 的 buildFdPathQuery：带 `/` 的查询按段转义、段间允许 `/` 或 `\` */
+function buildFdPathQuery(query: string): string {
+	const normalized = toDisplayPath(query);
+	if (!normalized.includes("/")) return normalized;
+	const trimmed = normalized.replace(/^\/+|\/+$/g, "");
+	if (!trimmed) return normalized;
+	const segments = trimmed.split("/").filter(Boolean).map(escapeRegex);
+	if (!segments.length) return normalized;
+	const separator = "[\\\\/]";
+	return segments.join(separator) + (normalized.endsWith("/") ? separator : "");
+}
+
+/**
+ * fd 的过滤：模式当正则，smart case（模式里有大写字母才区分大小写，转义序列如 `\W` 不算）。
+ * fd 用的是 Rust 正则，`c++` 这种叠加量词它能编（等于 `(c+)+`），JS 会报错：
+ * 编不过就退回字面包含——之后 scoreEntry 本来就要求查询按字面出现，所以 `c++` 的结果和 pi 一样；
+ * Rust 也编不过的（未闭合的括号等）pi 没有候选，这里按字面给，算有意放宽。
+ */
+function fdFilter(pattern: string): (target: string) => boolean {
+	const caseSensitive = /\p{Lu}/u.test(pattern.replace(/\\./g, ""));
+	try {
+		const regex = new RegExp(pattern, caseSensitive ? "" : "i");
+		return (target) => regex.test(target);
+	} catch {
+		const literal = caseSensitive ? pattern : pattern.toLowerCase();
+		return (target) => (caseSensitive ? target : target.toLowerCase()).includes(literal);
+	}
+}
+
+/** pi 的 scoreEntry：文件名全等 100 / 前缀 80 / 包含 50 / 整条路径包含 30，目录命中再 +10 */
+export function scoreEntry(filePath: string, query: string, isDirectory: boolean): number {
+	const lowerFileName = baseName(filePath).toLowerCase();
+	const lowerQuery = query.toLowerCase();
+	let score = 0;
+	if (lowerFileName === lowerQuery) score = 100;
+	else if (lowerFileName.startsWith(lowerQuery)) score = 80;
+	else if (lowerFileName.includes(lowerQuery)) score = 50;
+	else if (filePath.toLowerCase().includes(lowerQuery)) score = 30;
+	if (isDirectory && score > 0) score += 10;
+	return score;
+}
+
+/**
+ * pi 的 resolveScopedFuzzyQuery：最后一个 `/` 之前是目录（必须存在），之后是查询。
+ * 返回 base = 工作区相对路径（"" 为根），displayBase = 用户打的原样前缀。
+ */
+function resolveScopedQuery(rawQuery: string, dirs: ReadonlySet<string>): { base: string; query: string; displayBase: string } | null {
+	const normalized = toDisplayPath(rawQuery);
+	const slash = normalized.lastIndexOf("/");
+	if (slash === -1) return null;
+	const displayBase = normalized.slice(0, slash + 1);
+	if (displayBase.startsWith("/") || displayBase.startsWith("~/")) return null;
+	const segments: string[] = [];
+	for (const segment of displayBase.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (!segments.length) return null;
+			segments.pop();
+		} else segments.push(segment);
+	}
+	const base = segments.join("/");
+	if (base && !dirs.has(base)) return null;
+	return { base, query: normalized.slice(slash + 1), displayBase };
+}
+
+interface Entry {
+	candidate: PathCandidate;
+	/** 相对 fd 搜索目录的路径，目录带尾斜杠（和 fd 的输出一致，长度和字典序都按它算） */
+	path: string;
+	score: number;
+	depth: number;
+}
+
+/**
+ * 候选排序与截断，和 pi 一致：空查询全部 1 分，按层级 → 路径长度 → 字典序（先看当前目录、名字短的在前）。
+ * 不在模块里缓存目录集合：调用方用 useMemo 包住整次计算。
+ */
+export function suggestPaths(candidates: readonly PathCandidate[], rawQuery: string, limit = MENTION_LIMIT): MentionSuggestion[] {
+	const dirs = new Set<string>();
+	for (const candidate of candidates) if (candidate.dir) dirs.add(candidate.path);
+	const scoped = resolveScopedQuery(rawQuery, dirs);
+	const query = scoped ? scoped.query : rawQuery;
+	const prefix = scoped?.base ? `${scoped.base}/` : "";
+
+	let filter: ((relative: string) => boolean) | null = null;
+	if (query) {
+		// 默认只拿文件名去匹配；查询带 `/` 时（目录不存在、没走上面的限定目录）匹配整条路径
+		const fullPath = toDisplayPath(query).includes("/");
+		const matches = fdFilter(buildFdPathQuery(query));
+		filter = fullPath ? matches : (relative) => matches(baseName(relative));
+	}
+
+	const entries: Entry[] = [];
+	for (const candidate of candidates) {
+		if (prefix && !candidate.path.startsWith(prefix)) continue;
+		const relative = candidate.path.slice(prefix.length);
+		if (!relative || (filter && !filter(relative))) continue;
+		const path = candidate.dir ? `${relative}/` : relative;
+		const score = query ? scoreEntry(path, query, candidate.dir) : 1;
+		if (score <= 0) continue;
+		entries.push({ candidate, path, score, depth: relative.split("/").filter(Boolean).length });
+	}
+	entries.sort((a, b) => b.score - a.score || a.depth - b.depth || a.path.length - b.path.length || a.path.localeCompare(b.path));
+
+	return entries.slice(0, limit).map(({ candidate, path }) => {
+		const withoutSlash = candidate.dir ? path.slice(0, -1) : path;
+		return {
+			candidate,
+			label: baseName(withoutSlash) + (candidate.dir ? "/" : ""),
+			description: scoped ? `${scoped.displayBase}${withoutSlash}` : withoutSlash,
+		};
+	});
+}
+
+// ---------- @ token（pi-tui extractAtPrefix） ----------
+
+/** pi 的 PATH_DELIMITERS */
+const PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
+/** pi-tui utils.js 的 cjkBreakRegex / cjkPunctuationRegex / autocompleteSeparatorRegex（原样抄来，测试里核对 source） */
+export const CJK_BREAK_REGEX = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+const CJK_PUNCTUATION_REGEX = new RegExp(`(?:(?=\\p{Punctuation})${CJK_BREAK_REGEX.source}|[，．：；！？（）［］｛｝“”‘’…—])`, "u");
+export const AUTOCOMPLETE_SEPARATOR_REGEX = new RegExp(`(?:\\s|${CJK_PUNCTUATION_REGEX.source})`, "u");
+const TOKEN_START_REGEX = new RegExp(`(?:^|${AUTOCOMPLETE_SEPARATOR_REGEX.source})$`, "u");
+/** 正文里路径前常见的左括号类：`(@src` 也能触发；token 里有对应的右括号就保留（`app/[slug]`） */
+const PATH_WRAPPERS: Record<string, string> = { "(": ")", "[": "]", "{": "}", "<": ">", "`": "`" };
+
+function isDelimiter(character: string): boolean {
+	return PATH_DELIMITERS.has(character) || AUTOCOMPLETE_SEPARATOR_REGEX.test(character);
+}
+
+/** 最后一个分隔符的位置（按码点走，返回它最后一个 UTF-16 单元的下标），没有则 -1 */
+function findLastDelimiter(text: string): number {
+	let last = -1;
+	let index = 0;
+	for (const character of text) {
+		index += character.length;
+		if (isDelimiter(character)) last = index - 1;
+	}
+	return last;
+}
+
+function stripLeadingWrappers(token: string): string {
+	let result = token;
+	while (result.length > 0) {
+		const closer = PATH_WRAPPERS[result[0]];
+		if (!closer || result.includes(closer, 1)) break;
+		result = result.slice(1);
+	}
+	return result;
+}
+
+function findUnclosedQuoteStart(text: string): number | null {
+	let inQuotes = false;
+	let quoteStart = -1;
+	for (let i = 0; i < text.length; i += 1) {
+		if (text[i] === '"') {
+			inQuotes = !inQuotes;
+			if (inQuotes) quoteStart = i;
+		}
+	}
+	return inQuotes ? quoteStart : null;
+}
+
+function isTokenStart(text: string, index: number): boolean {
+	let start = index;
+	while (start > 0 && PATH_WRAPPERS[text[start - 1]]) start -= 1;
+	return PATH_DELIMITERS.has(text[start - 1] ?? "") || TOKEN_START_REGEX.test(text.slice(0, start));
+}
+
+/**
+ * 光标前的 `@` 引用 token，规则同 pi：
+ * 从最后一个分隔符（空白、`"` `'` `=`、中日韩标点）之后取一段，去掉开头的左括号类，以 `@` 开头才算
+ * （`foo@bar` 这种邮箱不触发）；另支持 `@"带空格 的路径`。返回 null 表示当前不该弹候选。
+ * pi 只看光标所在的那一行；光标在 token 中间时（`@lib|bar`）删除范围盖住整个 token，免得留下半截。
+ */
+export function atToken(text: string, caret: number): { query: string; start: number; end: number; tokenEnd: number } | null {
+	const end = Math.max(0, Math.min(caret, text.length));
+	const lineStart = text.lastIndexOf("\n", end - 1) + 1;
+	const line = text.slice(lineStart, end);
+
+	const quoteStart = findUnclosedQuoteStart(line);
+	if (quoteStart !== null && quoteStart > 0 && line[quoteStart - 1] === "@" && isTokenStart(line, quoteStart - 1)) {
+		const close = text.indexOf('"', end);
+		const lineEnd = text.indexOf("\n", end);
+		const closed = close !== -1 && (lineEnd === -1 || close < lineEnd);
+		return { query: line.slice(quoteStart + 1), start: lineStart + quoteStart - 1, end, tokenEnd: closed ? close + 1 : end };
+	}
+
+	const tokenStart = findLastDelimiter(line) + 1;
+	const raw = line.slice(tokenStart);
+	const token = stripLeadingWrappers(raw);
+	if (!token.startsWith("@")) return null;
+	let tokenEnd = end;
+	for (const character of text.slice(end)) {
+		if (isDelimiter(character)) break;
+		tokenEnd += character.length;
+	}
+	return { query: token.slice(1), start: lineStart + tokenStart + raw.length - token.length, end, tokenEnd };
+}

package/.next/server/chunks/131.js

@@ -1 +0,0 @@
-"use strict";exports.id=131,exports.ids=[131],exports.modules={6512:(a,b,c)=>{c.d(b,{Kt:()=>f,W8:()=>e});let d=["off","minimal","low","medium","high","xhigh","max"];function e(a){return a.reasoning?d.filter(b=>{let c=a.thinkingLevelMap?.[b];return null!==c&&("xhigh"!==b&&"max"!==b||void 0!==c)}):["off"]}function f(a,b){let c=e(a);if(c.includes(b))return b;let f=d.indexOf(b);if(-1===f)return c[0]??"off";for(let a=f;a<d.length;a++){let b=d[a];if(c.includes(b))return b}for(let a=f-1;a>=0;a--){let b=d[a];if(c.includes(b))return b}return c[0]??"off"}}};