@rexvane/piweb 0.3.21 → 0.3.23

package/src/components/side-chat/request-history.ts

@@ -0,0 +1,29 @@
+import { SIDE_CHAT_BODY_LIMIT, SIDE_CHAT_HISTORY_LIMIT, SIDE_CHAT_TEXT_LIMIT, type SideChatHistoryMessage } from "@/lib/side-chat/types";
+
+/** Bound only the transmitted context; the browser retains the original transcript. */
+export function requestHistory(messages: SideChatHistoryMessage[]): { history: SideChatHistoryMessage[]; truncated: boolean } {
+ const encoder = new TextEncoder();
+ const history: SideChatHistoryMessage[] = [];
+ // Reserve the other half for the question (including JSON escapes), model and envelope.
+ let remaining = Math.floor(SIDE_CHAT_BODY_LIMIT / 2) - 2;
+ let truncated = false;
+ for (let i = messages.length - 1; i >= 0; i--) {
+  if (history.length === SIDE_CHAT_HISTORY_LIMIT) { truncated = true; break; }
+  const message = messages[i];
+  let text = message.text;
+  if (text.length > SIDE_CHAT_TEXT_LIMIT) {
+   text = text.slice(-SIDE_CHAT_TEXT_LIMIT);
+   if (/^[\uDC00-\uDFFF]/.test(text)) text = text.slice(1);
+   truncated = true;
+  }
+  const entry = { role: message.role, text };
+  const size = encoder.encode(JSON.stringify(entry)).byteLength + 1;
+  if (size > remaining) { truncated = true; break; }
+  remaining -= size;
+  history.push(entry);
+ }
+ history.reverse();
+ // A retained transcript must begin with a question, not an orphaned answer.
+ while (history[0]?.role === "assistant") { history.shift(); truncated = true; }
+ return { history, truncated };
+}

package/src/components/side-chat/store.ts

@@ -0,0 +1,248 @@
+"use client";
+
+import { isSideChatId, isSideChatModel, type SideChatModel, type SideChatHistoryMessage, type SideChatProgress, type SideChatRequest, type SideChatUsage } from "@/lib/side-chat/types";
+
+import { requestHistory } from "./request-history";
+
+export interface SideChatMessage {
+	id: string;
+	role: "user" | "assistant";
+	text: string;
+	status?: "pending" | "done" | "error" | "aborted";
+	error?: string;
+	contextTruncated?: boolean;
+	lengthLimited?: boolean;
+}
+export interface SideChatThread {
+	id: string;
+	title: string;
+	messages: SideChatMessage[];
+	draft: string;
+	model?: SideChatModel;
+	request?: { id: string; revision: number };
+	/** 最近一次回答的真实用量与窗口：面板右下角的上下文环用它 */
+	usage?: SideChatUsage;
+	contextWindow?: number;
+	/** 这次上下文的真实字符分项（系统提示词 / 引用的主会话背景） */
+	characters?: { systemPrompt: number; background: number };
+	connectionLost?: boolean;
+}
+export interface SideChatState {
+	currentThreadId: string;
+	threads: SideChatThread[];
+	storageFailed: boolean;
+}
+export const EMPTY_SIDE_CHAT: SideChatState = { currentThreadId: "", threads: [], storageFailed: false };
+const PREFIX = "piweb.sidechat.v1.";
+
+class ApiError extends Error {
+	constructor(message: string, readonly status: number) { super(message); }
+}
+
+function pause(ms: number, signal: AbortSignal): Promise<void> {
+	return new Promise((resolve) => {
+		const finish = () => { clearTimeout(timer); signal.removeEventListener("abort", finish); resolve(); };
+		const timer = setTimeout(finish, ms);
+		signal.addEventListener("abort", finish, { once: true });
+		if (signal.aborted) finish();
+	});
+}
+
+/** Browser-owned threads outlive panel unmounts. Only their own subscribers render on an answer update. */
+export class SideChatStore {
+	private states = new Map<string, SideChatState>();
+	private listeners = new Map<string, Set<() => void>>();
+	private requests = new Map<string, AbortController>();
+	private saves = new Map<string, ReturnType<typeof setTimeout>>();
+	constructor(private options: { fetch: typeof fetch; storage: () => Storage; id: () => string } = {
+		fetch: (...args) => fetch(...args), storage: () => localStorage, id: () => crypto.randomUUID(),
+	}) {}
+
+	get = (sessionId: string | null): SideChatState => {
+		if (!sessionId) return EMPTY_SIDE_CHAT;
+		let state = this.states.get(sessionId);
+		if (state) return state;
+		try {
+			const raw = this.options.storage().getItem(PREFIX + sessionId);
+			if (raw) {
+				const saved = JSON.parse(raw) as SideChatState;
+				if (isSideChatId(saved.currentThreadId) && Array.isArray(saved.threads) && saved.threads.length && saved.threads.every((thread) =>
+					isSideChatId(thread.id) && typeof thread.title === "string" && typeof thread.draft === "string" && Array.isArray(thread.messages) && thread.messages.every((message) =>
+						isSideChatId(message.id) && (message.role === "user" || message.role === "assistant") && typeof message.text === "string") &&
+					(!thread.request || (isSideChatId(thread.request.id) && Number.isSafeInteger(thread.request.revision)))) && saved.threads.some((thread) => thread.id === saved.currentThreadId)) {
+					state = { ...saved, storageFailed: false, threads: saved.threads.map((thread) => ({ ...thread, model: isSideChatModel(thread.model) ? thread.model : undefined })) };
+				}
+			}
+		} catch { /* A unavailable or full browser store must not disable questions. */ }
+		if (!state) {
+			const thread = this.newThread();
+			state = { currentThreadId: thread.id, threads: [thread], storageFailed: false };
+		}
+		this.states.set(sessionId, state);
+		return state;
+	};
+
+	flush = (): void => { for (const sessionId of this.states.keys()) this.save(sessionId); };
+
+	subscribe = (sessionId: string | null, listener: () => void): (() => void) => {
+		if (!sessionId) return () => {};
+		const listeners = this.listeners.get(sessionId) ?? new Set();
+		listeners.add(listener);
+		this.listeners.set(sessionId, listeners);
+		queueMicrotask(() => {
+			for (const thread of this.get(sessionId).threads) {
+				if (thread.request && !this.requests.has(thread.request.id)) void this.run(sessionId, thread.id, thread.request.id);
+			}
+		});
+		return () => { listeners.delete(listener); };
+	};
+
+	private newThread(model?: SideChatModel): SideChatThread { return { id: this.options.id(), title: "", messages: [], draft: "", ...(model ? { model: { ...model } } : {}) }; }
+	private notify(sessionId: string): void { for (const listener of this.listeners.get(sessionId) ?? []) listener(); }
+	private save(sessionId: string): void {
+		const timer = this.saves.get(sessionId);
+		if (timer) clearTimeout(timer);
+		this.saves.delete(sessionId);
+		const state = this.get(sessionId);
+		let failed = false;
+		try { this.options.storage().setItem(PREFIX + sessionId, JSON.stringify(state)); }
+		catch { failed = true; }
+		if (state.storageFailed !== failed) {
+			this.states.set(sessionId, { ...state, storageFailed: failed });
+			this.notify(sessionId);
+		}
+	}
+	private update(sessionId: string, state: SideChatState, immediately = false): void {
+		this.states.set(sessionId, state);
+		this.notify(sessionId);
+		if (immediately) this.save(sessionId);
+		else if (!this.saves.has(sessionId)) this.saves.set(sessionId, setTimeout(() => this.save(sessionId), 300));
+	}
+	private updateThread(sessionId: string, threadId: string, change: (thread: SideChatThread) => SideChatThread, immediately = false): void {
+		const state = this.get(sessionId);
+		this.update(sessionId, { ...state, threads: state.threads.map((thread) => thread.id === threadId ? change(thread) : thread) }, immediately);
+	}
+
+	setDraft(sessionId: string, text: string): void {
+		this.updateThread(sessionId, this.get(sessionId).currentThreadId, (thread) => ({ ...thread, draft: text }));
+	}
+	setModel(sessionId: string, model?: SideChatModel): void {
+		this.updateThread(sessionId, this.get(sessionId).currentThreadId, (thread) => ({ ...thread, model: model ? { ...model } : undefined }), true);
+	}
+	createThread(sessionId: string): void {
+		const state = this.get(sessionId);
+		const current = state.threads.find((thread) => thread.id === state.currentThreadId);
+		if (current && !current.messages.length && !current.draft) return;
+		const thread = this.newThread(current?.model);
+		this.update(sessionId, { ...state, currentThreadId: thread.id, threads: [...state.threads, thread] }, true);
+	}
+	selectThread(sessionId: string, threadId: string): void {
+		const state = this.get(sessionId);
+		if (state.threads.some((thread) => thread.id === threadId)) this.update(sessionId, { ...state, currentThreadId: threadId }, true);
+	}
+
+	send(sessionId: string, retry = false): void {
+		const state = this.get(sessionId);
+		const thread = state.threads.find((item) => item.id === state.currentThreadId);
+		if (!thread || thread.request) return;
+		const previous = thread.messages.at(-1);
+		const retrying = retry && previous?.role === "assistant" && previous.status === "error" && thread.messages.at(-2)?.role === "user";
+		const text = (retrying ? thread.messages.at(-2)!.text : thread.draft).trim();
+		if (!text) return;
+		const requestId = this.options.id();
+		const historyMessages = retrying ? thread.messages.slice(0, -2) : thread.messages;
+		const availableHistory: SideChatHistoryMessage[] = historyMessages.filter((message) => message.text && (message.role === "user" || message.status === "done" || message.status === "aborted"))
+			.map(({ role, text }) => ({ role, text }));
+		const { history, truncated } = requestHistory(availableHistory);
+		const messages: SideChatMessage[] = retrying
+			? [...thread.messages.slice(0, -1), { id: previous!.id, role: "assistant", text: "", status: "pending", contextTruncated: truncated }]
+			: [...thread.messages, { id: this.options.id(), role: "user", text }, { id: this.options.id(), role: "assistant", text: "", status: "pending", contextTruncated: truncated }];
+		this.updateThread(sessionId, thread.id, (item) => ({ ...item, title: item.title || text.slice(0, 80), messages, draft: retrying ? item.draft : "", request: { id: requestId, revision: -1 }, connectionLost: false }), true);
+		void this.run(sessionId, thread.id, requestId, { requestId, threadId: thread.id, text, history, ...(thread.model ? { model: { ...thread.model } } : {}) });
+	}
+
+	private apply(sessionId: string, threadId: string, requestId: string, progress: SideChatProgress): void {
+		this.updateThread(sessionId, threadId, (thread) => {
+			if (thread.request?.id !== requestId) return thread;
+			const previousText = thread.messages.at(-1)?.text ?? "";
+			if (progress.textOffset !== undefined && progress.textOffset > previousText.length) throw new Error("side-chat answer cursor is out of sync");
+			const text = progress.textOffset === undefined ? progress.text : previousText.slice(0, progress.textOffset) + progress.text;
+			const status = !progress.done ? "pending" : progress.error ? "error" : progress.aborted ? "aborted" : "done";
+			return {
+				...thread, connectionLost: false, request: progress.done ? undefined : { id: requestId, revision: progress.revision },
+				// 只在这次响应真的报了就更新；没报就保持上一次的值（不回落成 0）
+				...(progress.usage ? { usage: progress.usage } : {}),
+				...(progress.contextWindow ? { contextWindow: progress.contextWindow } : {}),
+				...(progress.characters ? { characters: progress.characters } : {}),
+				messages: thread.messages.map((message, index) => index === thread.messages.length - 1 ? {
+					...message, text, status, error: progress.error, contextTruncated: message.contextTruncated || progress.contextTruncated, lengthLimited: progress.lengthLimited,
+				} : message),
+			};
+		}, progress.done);
+	}
+	private fail(sessionId: string, threadId: string, requestId: string, error: string): void {
+		const thread = this.get(sessionId).threads.find((item) => item.id === threadId);
+		this.apply(sessionId, threadId, requestId, { requestId, revision: 0, text: thread?.messages.at(-1)?.text ?? "", done: true, aborted: false, error });
+	}
+	private async response(response: Response): Promise<SideChatProgress> {
+		const json = await response.json();
+		if (!response.ok || !json.success) throw new ApiError(json.error || `side-chat request failed (${response.status})`, response.status);
+		const data = json.data as SideChatProgress;
+		if (!data || !isSideChatId(data.requestId) || !Number.isSafeInteger(data.revision) || typeof data.text !== "string" || typeof data.done !== "boolean" || (data.textOffset !== undefined && (!Number.isSafeInteger(data.textOffset) || data.textOffset < 0))) throw new Error("invalid side-chat response");
+		return data;
+	}
+	private async run(sessionId: string, threadId: string, requestId: string, initial?: SideChatRequest): Promise<void> {
+		if (this.requests.has(requestId)) return;
+		const controller = new AbortController();
+		this.requests.set(requestId, controller);
+		const url = `/api/agent/${sessionId}/side-chat`;
+		let revision = this.get(sessionId).threads.find((thread) => thread.id === threadId)?.request?.revision ?? -1;
+		try {
+			if (initial) {
+				const progress = await this.response(await this.options.fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(initial), signal: controller.signal }));
+				if (progress.requestId !== requestId) throw new Error("side-chat response belongs to a different request");
+				if (controller.signal.aborted) return;
+				this.apply(sessionId, threadId, requestId, progress);
+				if (progress.done) return;
+				revision = progress.revision;
+			}
+			let failures = 0;
+			while (!controller.signal.aborted) {
+				let progress: SideChatProgress;
+				try {
+					progress = await this.response(await this.options.fetch(`${url}?requestId=${encodeURIComponent(requestId)}&after=${revision}`, { cache: "no-store", signal: controller.signal }));
+					if (progress.requestId !== requestId) throw new Error("side-chat response belongs to a different request");
+				} catch (error) {
+					if (controller.signal.aborted) return;
+					if (error instanceof ApiError || ++failures >= 6) throw error;
+					this.updateThread(sessionId, threadId, (thread) => ({ ...thread, connectionLost: true }));
+					await pause(Math.min(500 * 2 ** (failures - 1), 5000), controller.signal);
+					continue;
+				}
+				if (controller.signal.aborted) return;
+				failures = 0;
+				this.apply(sessionId, threadId, requestId, progress);
+				if (progress.done) return;
+				revision = progress.revision;
+			}
+		} catch (error) {
+			if (!controller.signal.aborted) this.fail(sessionId, threadId, requestId, error instanceof Error ? error.message : "side-chat request failed");
+		} finally {
+			if (this.requests.get(requestId) === controller) this.requests.delete(requestId);
+		}
+	}
+
+	stop(sessionId: string): void {
+		const thread = this.get(sessionId).threads.find((item) => item.id === this.get(sessionId).currentThreadId);
+		const requestId = thread?.request?.id;
+		if (!thread || !requestId) return;
+		this.requests.get(requestId)?.abort();
+		this.apply(sessionId, thread.id, requestId, { requestId, revision: 0, text: thread.messages.at(-1)?.text ?? "", done: true, aborted: true });
+		void this.options.fetch(`/api/agent/${sessionId}/side-chat?requestId=${encodeURIComponent(requestId)}`, { method: "DELETE" })
+			.then(async (response) => { if (!response.ok) throw new Error((await response.json()).error || "failed to stop side-chat answer"); })
+			.catch((error) => this.updateThread(sessionId, thread.id, (current) => ({ ...current, messages: current.messages.map((message) => message.id === thread.messages.at(-1)?.id ? { ...message, error: error instanceof Error ? error.message : "failed to stop side-chat answer" } : message) }), true));
+	}
+}
+
+export const sideChatStore = new SideChatStore();
+if (typeof window !== "undefined") window.addEventListener("pagehide", sideChatStore.flush);

package/src/hooks/useFileViewer.ts

@@ -8,11 +8,13 @@ import { useCallback, useState } from "react";
 
 export interface ViewerTab {
 	path: string;
-	/** 重命名前的路径（取 diff 用） */
+	/** 重命名前的路径(取 diff 用) */
 	from?: string;
-	/** 快照之外的文件（node_modules 等）：只能看磁盘上的当前内容 */
+	/** 快照之外的文件(node_modules 等):只能看磁盘上的当前内容 */
 	lazy?: boolean;
-	/** 内容由调用方直接提供（如技能文档）：不取 diff、不读磁盘 */
+	/** dir = 打开的是文件夹:正文区列目录(可逐层进入),不是文件内容 */
+	kind?: "dir" | "file";
+	/** 内容由调用方直接提供(如技能文档):不取 diff、不读磁盘 */
 	staticContent?: string;
 }
 
@@ -25,7 +27,7 @@ export interface ViewerState {
 
 export function useFileViewer() {
 	const [state, setState] = useState<ViewerState>({ open: false, tabs: [], active: null });
-	const open = useCallback((path: string, opts: { from?: string; lazy?: boolean } = {}) => {
+	const open = useCallback((path: string, opts: { from?: string; lazy?: boolean; kind?: "dir" | "file" } = {}) => {
 		setState((s) => {
 			const exists = s.tabs.some((tab) => tab.path === path);
 			const tabs = exists ? s.tabs.map((tab) => (tab.path === path ? { ...tab, ...opts } : tab)) : [...s.tabs, { path, ...opts }];

package/src/hooks/useGrowth.ts

@@ -39,6 +39,8 @@ export interface GrowthApi {
 	range: { from: string; to: string } | null;
 	/** 所选范围的变更 */
 	changes: GrowthChange[];
+	/** 当前范围的完整 diff 已读取；加载或失败时不能将 [] 当成零改动。 */
+	changesReady?: boolean;
 	tree: TreeNode;
 	/** 所选轮的全部文件路径（快速打开用） */
 	filePaths: string[];
@@ -618,6 +620,7 @@ export function useGrowth({
 		scope,
 		range,
 		changes,
+		changesReady: inlineChanges !== null || Boolean(range && rangeChanges?.key === `${key}|${range.from}..${range.to}` && !rangeChanges.error),
 		tree,
 		filePaths,
 		expanded,

package/src/hooks/usePiWeb.ts

@@ -76,6 +76,10 @@ export const foldPiWebEvent = (state: PiWebState, evt: WebEvent): PiWebState =>
 	const s = { ...state };
 	switch (evt.type) {
 		case "delta": {
+			// 又开始出 token 了：不管有没有收到重试结束事件，重试行都收掉。
+			// 只靠 retry_end 不够——SDK 换了事件名、某条路径没发结束事件、旧服务端压根不发，
+			// 界面就会挂着「重试 1/5」而模型其实早在正常输出了（用户已反馈两次）。
+			s.retryNotice = null;
 			// 新服务端按稳定流 ID 定位；旧协议仍按最近 pending 消息兼容。
 			const msgs = [...s.messages];
 			// 从尾部找：增量几乎总是落在最后一条消息上，长会话里从头扫每个 token 都是一次全表遍历
@@ -251,11 +255,17 @@ export const foldPiWebEvent = (state: PiWebState, evt: WebEvent): PiWebState =>
 			s.growth = { ...s.growth, consent: evt.request };
 			return s;
 		case "retry":
-			// 只保留最后一次尝试：重试过程在界面上是「重试 3/5」这一条，而不是五行报错
+			// 只保留最后一次尝试:重试过程在界面上是「重试 3/5」这一条,而不是五行报错
 			s.retryNotice = evt.maxAttempts
 				? `重试 ${evt.attempt}/${evt.maxAttempts}${evt.message ? `：${evt.message}` : ""}`
 				: `重试 ${evt.attempt}${evt.message ? `：${evt.message}` : ""}`;
 			return s;
+		case "retry_end":
+			// 重试区间结束(SDK auto_retry_end):立刻收掉重试行。
+			// 重试常发生在下一轮 agent 开始之前,而那段间隙不会发 status:isStreaming=false,
+			// 所以不能只等 agent_settled —— 否则用户会一直看到「重试 1/5 terminated」。
+			s.retryNotice = null;
+			return s;
 		case "error":
 			// 旧服务端把自动重试塞在 error 里：同样按通知处理，不占错误条
 			if (/^(自动重试|重试)/.test(evt.message)) s.retryNotice = evt.message;
@@ -809,7 +819,7 @@ export function usePiWeb() {
 				const id = idOf(p);
 				// 工具预设取通用设置的持久化选择；模型/思考级别由 Hero 页显式下发
 				const setup: Record<string, unknown>[] = [{ cmd: "setToolPreset", preset: savedToolPreset() }];
-				if (overrides.provider && overrides.modelId) setup.push({ cmd: "setModel", provider: overrides.provider, modelId: overrides.modelId });
+				if (overrides.provider && overrides.modelId) setup.push({ cmd: "setModel", provider: overrides.provider, modelId: overrides.modelId, fresh: true });
 				if (overrides.thinking) setup.push({ cmd: "setThinkingLevel", level: overrides.thinking });
 				for (const command of setup) {
 					const configured = await sendCommand(command, id);

package/src/hooks/useWorkspaceFiles.ts

@@ -0,0 +1,93 @@
+"use client";
+
+/**
+ * @ 引用的候选文件：打开候选菜单时拉一次全量清单，之后每个字符都在本地匹配。
+ * 按工作区缓存（含 in-flight 去重），过期后**先用手上的旧清单渲染、再后台刷新**——
+ * 打字过程中绝不能因为一次刷新把候选列表清空。
+ */
+import { useEffect, useRef, useState } from "react";
+import { buildCandidates, dirsOfPaths, type PathCandidate } from "@/lib/workspace-index";
+
+export interface WorkspaceFiles {
+	status: "idle" | "loading" | "ready" | "error";
+	candidates: PathCandidate[];
+	source: "git" | "disk" | null;
+	truncated: boolean;
+	error: string | null;
+}
+
+/** 清单多久算过期：agent 刚写出来的新文件也要能被引用到，所以不能一直用内存里那份 */
+const TTL_MS = 30_000;
+
+interface CachedIndex {
+	at: number;
+	candidates: PathCandidate[];
+	source: "git" | "disk";
+	truncated: boolean;
+}
+
+const cache = new Map<string, CachedIndex>();
+const inflight = new Map<string, Promise<CachedIndex>>();
+
+async function fetchIndex(cwd: string): Promise<CachedIndex> {
+	const response = await fetch(`/api/files?index=1&cwd=${encodeURIComponent(cwd)}`, { cache: "no-store" });
+	const payload = await response.json();
+	if (!response.ok || !payload.success) throw new Error(payload.error || `request failed (${response.status})`);
+	const data = payload.data as { files: string[]; source: "git" | "disk"; truncated: boolean };
+	const entry: CachedIndex = {
+		at: Date.now(),
+		candidates: buildCandidates(data.files, dirsOfPaths(data.files)),
+		source: data.source,
+		truncated: data.truncated,
+	};
+	cache.set(cwd, entry);
+	return entry;
+}
+
+/**
+ * 同一工作区并发只发一次请求；失败不进缓存（下次打开会重试）。
+ * 共享的请求不挂任何一方的 AbortSignal：先打开的输入框关了（中止），后来的还在等同一个结果，
+ * 不能让它跟着收到 AbortError。各方用完就不理结果，请求本身让它跑完、顺手填进缓存。
+ */
+function loadIndex(cwd: string): Promise<CachedIndex> {
+	const running = inflight.get(cwd);
+	if (running) return running;
+	const promise = fetchIndex(cwd).finally(() => inflight.delete(cwd));
+	inflight.set(cwd, promise);
+	return promise;
+}
+
+export function useWorkspaceFiles(cwd: string, enabled: boolean): WorkspaceFiles {
+	const [state, setState] = useState<WorkspaceFiles>({ status: "idle", candidates: [], source: null, truncated: false, error: null });
+	const scope = useRef<{ cwd: string; controller: AbortController }>({ cwd: "", controller: new AbortController() });
+
+	useEffect(() => {
+		if (!enabled || !cwd) return;
+		const controller = new AbortController();
+		scope.current = { cwd, controller };
+		const isCurrent = () => scope.current.controller === controller && !controller.signal.aborted;
+
+		const cached = cache.get(cwd);
+		if (cached) {
+			// 有旧清单就先显示（旧的总比空白好），过期只在后台补
+			setState({ status: "ready", candidates: cached.candidates, source: cached.source, truncated: cached.truncated, error: null });
+			if (Date.now() - cached.at < TTL_MS) return () => controller.abort();
+		} else {
+			setState({ status: "loading", candidates: [], source: null, truncated: false, error: null });
+		}
+
+		void loadIndex(cwd).then(
+			(entry) => {
+				if (isCurrent()) setState({ status: "ready", candidates: entry.candidates, source: entry.source, truncated: entry.truncated, error: null });
+			},
+			(error: unknown) => {
+				// 有旧清单时忽略这次失败：刷新失败不该把可用候选变成错误页
+				if (!isCurrent() || cache.has(cwd)) return;
+				setState({ status: "error", candidates: [], source: null, truncated: false, error: error instanceof Error ? error.message : String(error) });
+			},
+		);
+		return () => controller.abort();
+	}, [cwd, enabled]);
+
+	return state;
+}