minimal-agent 0.10.0 → 0.12.0

package/src/ui/hooks/useChat.js

@@ -21,17 +21,28 @@ import { forceCompact } from '../../context/compact.js';
 import { clearContext, loadContext, saveContext, } from '../../context/persistContext.js';
 import { resetReactiveCompactState } from '../../context/reactiveCompact.js';
 import { acquireContextLock } from '../../context/contextLock.js';
+import { workspaceIndexService } from '../../context/workspaceIndex.js';
 import { getActiveSession, setActiveSession, updateSessionMetadata, } from '../../context/sessionRegistry.js';
 import { resolveSessionFile, sessionFileFor, } from '../../context/sessionPath.js';
-import { buildFullSystemPrompt } from '../../prompts/system.js';
+import { buildBaseSystemPrompt, buildTransientPromptBundle } from '../../prompts/system.js';
+import { createPromptCacheContext } from '../../llm/promptCache.js';
+import { createAgentRuntimeContext, filterToolsForRuntime, memoryContextFromRuntime, } from '../../runtime/agentRuntimeContext.js';
+import { startTurnJournal } from '../../memory/turnJournal.js';
 import { ALL_TOOLS, getToolByName } from '../../tools/index.js';
 import { createInputQueue } from '../../messageQueue.js';
 import { createAskCoordinator, setAskHandler, } from '../../askBridge.js';
 import { createAskSlot } from './askSlot.js';
 import { figures } from '../figures.js';
 import { clearFileState } from '../../tools/shared/fileState.js';
+import { getOrCreateSessionState, sessionStateKey } from '../../session/sessionState.js';
+import { hydrateSessionWorktree } from '../../tools/worktree/sessionWorktree.js';
+import { runAdvisor } from '../../tools/advisor/advisor.js';
 import { runWithPlugins } from '../../plugins/pluginRunner.js';
 import { dlog } from '../../utils/debugLog.js';
+import { createCliComputerRun, createComputerUseHostGate } from '../../cli/computerUse.js';
+import { computerUseService, } from '../../tools/computeruse/computerUseService.js';
+import { HumanInterventionCoordinator, } from '../../humanIntervention.js';
+import { createComputerInterventionAdapter } from '../../tools/computeruse/intervention.js';
 /**
  * reasoningPreview 环形 buffer 容量（字符）。
  * LiveArea 现在多行显示思维链尾部（最近 N 行），需要喂饱足够文本；
@@ -144,6 +155,19 @@ export function useChat(args) {
      * 路径）时该值仍是 null，StatusLine 降级回 useTokenUsage 估算。
      */
     const [contextUsage, setContextUsage] = useState(null);
+    const [computerUseMode, setComputerUseMode] = useState('disabled');
+    const promptToolSignatureRef = useRef('');
+    const activeComputerRunRef = useRef(null);
+    const [computerInterventions] = useState(() => new HumanInterventionCoordinator());
+    const [pendingComputerIntervention, setPendingComputerIntervention] = useState(null);
+    useEffect(() => computerInterventions.subscribe((event) => {
+        if (event.type === 'started') {
+            setPendingComputerIntervention(event.intervention);
+        }
+        else {
+            setPendingComputerIntervention((current) => current?.id === event.resolution.intervention.id ? null : current);
+        }
+    }), [computerInterventions]);
     /**
      * 工具并行执行：以 callId 为 key 保存所有运行中工具。
      * 用 Map 是为了 O(1) 增删；对外 memo 物化成稳定数组（Map 迭代顺序 = 插入顺序，
@@ -279,6 +303,69 @@ export function useChat(args) {
             cancelled = true;
         };
     }, []);
+    /**
+     * 最新 submit 的 latest-ref。runManualAdvisor 定义在 submit 之前（它不能依赖
+     * submit 的闭包），但结束时要把排队输入交回去执行 —— 用 ref 打破定义顺序，
+     * 而不是把两者的定义顺序倒过来（那会让 submit 依赖 runManualAdvisor，更绕）。
+     */
+    const submitRef = useRef(null);
+    /**
+     * `/advisor ask` 的执行体：让手动咨询和工具咨询共用同一套过程显示。
+     *
+     * 此前 App.tsx 里是裸 `await runAdvisor(...)` —— 顾问最长跑 180 秒，这期间 TUI
+     * 一个字都不动，也按不停。工具路径早就修过同款问题（advisor.ts 的 reportProgress
+     * 节流发布，源于 2026-07「2m05s 无变化被误判死机」的真实反馈），手动路径却没跟上：
+     * 同一个功能两条路径，用户**主动发起**的那条体验反而更差。
+     *
+     * 复用既有的 runningTools + progressStage（不新增 UI 概念）：塞一个运行中条目给
+     * LiveArea，进度行由 runAdvisor 的 reportProgress 驱动；挂 abortRef 让 ESC/Ctrl+C
+     * 真能掐断，而不是干等到超时。
+     */
+    const runManualAdvisor = useCallback(async (note) => {
+        if (isLoading) {
+            return { ok: false, error: '当前有任务在执行；等它结束或按 ESC 中断后再咨询顾问。' };
+        }
+        const callId = 'manual-advisor';
+        const ac = new AbortController();
+        abortRef.current = ac;
+        setIsLoading(true);
+        setProgressStage('tool_executing');
+        setRunningToolsMap(new Map([[callId, {
+                    toolName: 'Advisor',
+                    argsPreview: note ?? '',
+                    status: 'running',
+                    argsFriendly: '正在咨询顾问模型',
+                }]]));
+        try {
+            return await runAdvisor(note ? { note } : {}, ac.signal, {
+                history: historyRef.current,
+                advisorCalls: { used: 0, max: 1 },
+                advisorInvocation: 'manual',
+                reportProgress: (message) => {
+                    // advisor.ts 侧已有 200ms 节流，这里直接落状态即可。
+                    setRunningToolsMap((prev) => {
+                        const current = prev.get(callId);
+                        if (!current)
+                            return prev;
+                        return new Map(prev).set(callId, { ...current, progress: message });
+                    });
+                },
+            });
+        }
+        finally {
+            setIsLoading(false);
+            setProgressStage('idle');
+            setRunningToolsMap(new Map());
+            abortRef.current = null;
+            // ⚠️ 必须消费排队输入。设了 isLoading 之后，用户在咨询期间敲的内容会被
+            // submit 送进 inputQueue，而队列此前**只在 submit 自己的 finally 里**出队
+            // （见下方 consumeQueued）—— 手动咨询不走那条路径，排队的话就会静静躺着，
+            // 用户看到「排队 1 条」却永远不执行，直到下次提交才错序跑掉。
+            const queued = inputQueue.dequeue();
+            if (queued)
+                queueMicrotask(() => { void submitRef.current?.(queued.value); });
+        }
+    }, [isLoading, inputQueue]);
     const submit = useCallback(async (input) => {
         const trimmed = input.trim();
         if (trimmed.length === 0)
@@ -309,6 +396,8 @@ export function useChat(args) {
         const ac = new AbortController();
         abortRef.current = ac;
         let releaseContextLock = null;
+        let turnJournal = null;
+        let turnJournalStart = 0;
         dlog('ui', 'turn START', { input: trimmed.slice(0, 80) });
         // 长时间运行时（如工作流 agent 步骤）的定时 token 刷新：
         // runQuery 的 text/reasoning 事件不触发 bump，导致 StatusLine token 数
@@ -330,12 +419,103 @@ export function useChat(args) {
                 historyRef.current.length = 0;
                 historyRef.current.push(...latest, ...ephemeral);
             }
+            const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+            const computerRun = computerUseMode !== 'disabled'
+                ? createCliComputerRun({
+                    mode: computerUseMode,
+                    surface: 'tui',
+                    conversationKey: `workspace:${workspace?.id ?? getWorkingDir()}:session:${activeSessionIdRef.current}`,
+                    userInput: trimmed,
+                    allowedFileRoots: [getWorkingDir()],
+                    supervised: true,
+                })
+                : undefined;
+            activeComputerRunRef.current = computerRun ?? null;
+            const computerIntervention = computerRun
+                ? createComputerInterventionAdapter({
+                    coordinator: computerInterventions,
+                    context: computerRun,
+                    observe: async (signal) => {
+                        // Resume is a canonical boundary: it invalidates every old
+                        // coordinate/AX reference and clears the native takeover
+                        // cancellation for this run only.
+                        const response = await computerUseService.request(computerRun, { action: 'observe' }, signal);
+                        return response.ok ? response.state : undefined;
+                    },
+                })
+                : undefined;
+            const toolGate = computerRun ? createComputerUseHostGate(computerRun) : undefined;
+            const turnSessionState = getOrCreateSessionState(sessionStateKey({
+                surface: 'tui', workspaceId: workspace?.id,
+                cwd: workspace?.id ? undefined : getWorkingDir(),
+                sessionId: activeSessionIdRef.current,
+            }));
+            await hydrateSessionWorktree({
+                sessionState: turnSessionState, workspaceId: workspace?.id,
+                sessionId: activeSessionIdRef.current, cwd: getWorkingDir(),
+            });
+            const effectiveCwd = turnSessionState.activeWorktree?.path ?? getWorkingDir();
+            const runtimeContext = createAgentRuntimeContext({
+                surface: 'tui',
+                profile: 'main',
+                cwd: effectiveCwd,
+                workspaceId: workspace?.id,
+                sessionId: activeSessionIdRef.current,
+                owner: 'local-owner',
+                memoryAccess: 'read-write',
+                interactiveAsk: true,
+                computer: computerRun,
+                computerIntervention,
+                toolGate,
+            });
+            const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+            const toolSignature = `${effectiveCwd}\0${turnTools.map((tool) => tool.name).join(',')}`;
+            if (promptToolSignatureRef.current !== toolSignature) {
+                const stablePrompt = await buildBaseSystemPrompt(effectiveCwd, turnTools);
+                const rest = historyRef.current[0]?.role === 'system'
+                    ? historyRef.current.slice(1)
+                    : [...historyRef.current];
+                historyRef.current.length = 0;
+                historyRef.current.push({ role: 'system', content: stablePrompt }, ...rest);
+                promptToolSignatureRef.current = toolSignature;
+            }
+            // 每回合只刷新易变层；稳定层仅在实际能力目录变化时重建。
+            const turnTransient = await buildTransientPromptBundle({
+                cwd: effectiveCwd,
+                tools: turnTools,
+                runtime: {
+                    surface: 'tui',
+                    cwd: effectiveCwd,
+                    currentUserInput: trimmed,
+                    workspaceId: workspace?.id,
+                    sessionId: activeSessionIdRef.current,
+                    interactiveAsk: true,
+                    supervisedBrowser: false,
+                    memoryAccess: 'read-write',
+                },
+            }).catch(() => undefined);
+            // 会话原文记账（与 session/runTurn.ts 共用同一份实现）。
+            // TUI 不经过 runTurn，此前整条路径都不入库，SearchConversations 对 TUI 用户静默失效。
+            turnJournalStart = historyRef.current.length;
+            turnJournal = await startTurnJournal({
+                memoryContext: memoryContextFromRuntime(runtimeContext),
+                userInput: trimmed,
+            }).catch(() => null);
             for await (const ev of runWithPlugins(trimmed, {
                 provider: providerRef.current,
                 history: historyRef.current,
                 signal: ac.signal,
+                runtimeContext,
+                allowedTools: turnTools.map((tool) => tool.name),
+                sessionState: turnSessionState,
                 parseInlineImages: true,
+                ...(turnTransient ? { transientBundle: turnTransient } : {}),
+                promptCache: createPromptCacheContext(`workspace:${workspace?.id ?? getWorkingDir()}:session:${activeSessionIdRef.current}`),
                 hasQueuedInput: () => inputQueue.size() > 0,
+                memoryContext: memoryContextFromRuntime(runtimeContext),
+                ...(computerRun ? { computerRun } : {}),
+                ...(computerIntervention ? { computerIntervention } : {}),
+                ...(toolGate ? { toolGate } : {}),
                 onToolStart: (name, id) => {
                     const tool = getToolByName(name);
                     runningToolsRef.current.set(id, {
@@ -390,7 +570,14 @@ export function useChat(args) {
             resetTurnState();
             setPluginProgress(null);
             abortRef.current = null;
+            if (activeComputerRunRef.current) {
+                computerInterventions.abort(activeComputerRunRef.current);
+            }
+            activeComputerRunRef.current = null;
             runningToolsRef.current.clear();
+            // 记账失败不影响落盘与解锁（它是附加能力，不是功能）。
+            await turnJournal?.finish(historyRef.current, turnJournalStart).catch(() => undefined);
+            turnJournal = null;
             // v2 multi-session：持久化到当前 active session 文件。
             try {
                 await saveContext(historyRef.current, sessionFileFor(getWorkingDir(), activeSessionIdRef.current));
@@ -418,12 +605,63 @@ export function useChat(args) {
         toolBumpFlush,
         resetTurnState,
         inputQueue,
+        computerUseMode,
+        computerInterventions,
     ]);
+    // latest-ref 赋值：runManualAdvisor 的 finally 靠它把排队输入交回 submit。
+    // 渲染体内直接赋值是 latest-ref 的常规写法；用 useEffect 会晚一帧，而咨询
+    // 结束时机与渲染无关，晚一帧就可能取到上一轮的闭包。
+    submitRef.current = submit;
     const abort = useCallback(() => {
         inputQueue.clear();
         runningToolsRef.current.clear();
+        if (activeComputerRunRef.current) {
+            computerInterventions.abort(activeComputerRunRef.current);
+        }
         abortRef.current?.abort();
-    }, [inputQueue]);
+    }, [computerInterventions, inputQueue]);
+    const stopComputerUse = useCallback(async () => {
+        setComputerUseMode('disabled');
+        const context = activeComputerRunRef.current;
+        if (!context)
+            return '已撤销后续回合授权；当前没有正在运行的 Computer Use。';
+        computerInterventions.abort(context);
+        const response = await computerUseService.request(context, { action: 'stop' });
+        return response.ok
+            ? '已停止当前回合的 Computer Use，并撤销后续回合授权。'
+            : `已撤销后续回合授权；原生停止失败：${response.error?.message ?? '未知错误'}`;
+    }, [computerInterventions]);
+    const resumeComputerUse = useCallback(async () => {
+        const pending = pendingComputerIntervention;
+        if (!pending)
+            return '当前没有等待人工处理的 Computer Use。';
+        const resumed = computerInterventions.resume({
+            id: pending.id,
+            resumeToken: pending.resumeToken,
+            ownerId: pending.ownerId,
+            conversationKey: pending.conversationKey,
+            runId: pending.runId,
+        });
+        return resumed
+            ? '已恢复原 Computer Use 运行，将先重新观察目标应用再继续。'
+            : '人工介入请求已失效，请重新观察目标应用。';
+    }, [computerInterventions, pendingComputerIntervention]);
+    const cancelComputerUse = useCallback(async () => {
+        const pending = pendingComputerIntervention;
+        if (!pending)
+            return stopComputerUse();
+        const cancelled = computerInterventions.cancel({
+            id: pending.id,
+            resumeToken: pending.resumeToken,
+            ownerId: pending.ownerId,
+            conversationKey: pending.conversationKey,
+            runId: pending.runId,
+        });
+        setComputerUseMode('disabled');
+        return cancelled
+            ? '已取消当前人工介入并停止该 Computer Use 任务。'
+            : '人工介入请求已失效。';
+    }, [computerInterventions, pendingComputerIntervention, stopComputerUse]);
     const setProvider = useCallback((next) => {
         providerRef.current = next;
     }, []);
@@ -458,9 +696,10 @@ export function useChat(args) {
             return;
         // 生成全新的 system prompt（实时扫 skills + 拼项目指令），
         // 与启动时 main.tsx buildInitialHistory 行为完全一致
-        const newSystemPrompt = await buildFullSystemPrompt(getWorkingDir(), ALL_TOOLS);
+        const newSystemPrompt = await buildBaseSystemPrompt(getWorkingDir(), ALL_TOOLS);
         historyRef.current.length = 0;
         historyRef.current.push({ role: 'system', content: newSystemPrompt });
+        promptToolSignatureRef.current = '';
         // 允许新 session 再次触发反应式压缩自救
         resetReactiveCompactState();
         cancelAllThrottles();
@@ -474,7 +713,13 @@ export function useChat(args) {
         // 清空磁盘上的持久化文件（防止下次启动又加载损坏数据）
         await clearContext();
         // 清空 pre-read guard 状态表（防止跨 session 的 Read 记录污染新会话）
-        clearFileState();
+        const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+        clearFileState(getOrCreateSessionState(sessionStateKey({
+            surface: 'tui',
+            workspaceId: workspace?.id,
+            cwd: workspace?.id ? undefined : getWorkingDir(),
+            sessionId: activeSessionIdRef.current,
+        })).fileReads);
         // 刚清空，不需要再保存一次"空历史"
     }, [bump, isLoading, cancelAllThrottles, resetTurnState]);
     /**
@@ -494,7 +739,9 @@ export function useChat(args) {
         cancelAllThrottles();
         let success = false;
         try {
-            const r = await forceCompact(historyRef.current, args.provider);
+            const cwd = getWorkingDir();
+            const workspace = await workspaceIndexService.findByPath(cwd).catch(() => null);
+            const r = await forceCompact(historyRef.current, args.provider, undefined, undefined, createPromptCacheContext(`workspace:${workspace?.id ?? cwd}:session:${activeSessionIdRef.current}`));
             historyRef.current.length = 0;
             historyRef.current.push(...r.messages);
             // 压缩后 MessageList 要 remount，丢掉旧 <Static> 缓存
@@ -619,7 +866,7 @@ export function useChat(args) {
         }
         let systemPrompt;
         try {
-            systemPrompt = await buildFullSystemPrompt(targetCwd, ALL_TOOLS);
+            systemPrompt = await buildBaseSystemPrompt(targetCwd, ALL_TOOLS);
         }
         catch (error) {
             setError(`无法打开工作区：${error instanceof Error ? error.message : String(error)}`);
@@ -646,10 +893,17 @@ export function useChat(args) {
         setActiveSessionId(targetSessionId);
         historyRef.current.length = 0;
         historyRef.current.push({ role: 'system', content: systemPrompt });
+        promptToolSignatureRef.current = '';
         if (loaded?.length) {
             historyRef.current.push(...(loaded[0]?.role === 'system' ? loaded.slice(1) : loaded));
         }
-        clearFileState();
+        const targetWorkspace = await workspaceIndexService.findByPath(targetCwd).catch(() => null);
+        clearFileState(getOrCreateSessionState(sessionStateKey({
+            surface: 'tui',
+            workspaceId: targetWorkspace?.id,
+            cwd: targetWorkspace?.id ? undefined : targetCwd,
+            sessionId: targetSessionId,
+        })).fileReads);
         resetReactiveCompactState();
         cancelAllThrottles();
         setContextUsage(null);
@@ -679,6 +933,12 @@ export function useChat(args) {
         reasoningPreview,
         runningTools,
         contextUsage,
+        computerUseMode,
+        setComputerUseMode,
+        stopComputerUse,
+        pendingComputerIntervention,
+        resumeComputerUse,
+        cancelComputerUse,
         activeSessionId,
         queuedCount,
         queuedItems,
@@ -686,6 +946,7 @@ export function useChat(args) {
         abort,
         clearHistory,
         compactNow,
+        runManualAdvisor,
         switchSession,
         switchWorkspace,
         ephemeralLine,
@@ -866,6 +1127,9 @@ export function handleEvent(ev, setters) {
             setters.setCompactGeneration((g) => g + 1);
             setters.bump();
             break;
+        case 'harness_diagnostics':
+            // Diagnostics are intentionally local-safe and currently consumed by CLI/stream hosts.
+            break;
         case 'turn_done':
             setters.bump();
             break;