fix(chat): resolve the workspace target authoritatively at send time

A send inside the debounce window previously created the session at the
workspace root; allocation now awaits resolve-target with the submitted
text, honors an explicit pin (including keep-at-root), and surfaces
resolver failures instead of falling back to the root. Preview requests
are project-scoped and text-capped, pins reset on project change, and
cached project origin updates are monotonic so a stale index event can
never demote an explicit project.

Author: devswha

src/components/chat/hooks/useChatComposerState.ts

@@ -113,11 +113,12 @@ export function useChatComposerState(args: UseChatComposerStateArgs) {
   const optionsFor = useCallback((text: string): QueuedSendOptions => ({ model: gjcModel, effort: reasoningEffort, sessionSummary: sessionLabel(selectedSession, text) }), [gjcModel, reasoningEffort, selectedSession]);
   const upload = useCallback(async (files: File[]) => { if (!files.length) return []; const body = new FormData(); files.forEach((file) => body.append('images', file)); const response = await authenticatedFetch('/api/assets/images', { method: 'POST', headers: {}, body }); if (!response.ok) throw new Error('Failed to upload images'); return (await response.json()).images as unknown[]; }, []);
   const workspaceTarget = useWorkspaceTarget({ selectedProject, selectedSession, currentSessionId, input });
+  const { resolveForSend } = workspaceTarget;
   // A workspace root (e.g. `~/Projects`) never hosts a session itself: the
   // resolved child repo becomes the session's project, and it is what the
   // caller (ChatInterface's `establishSession`) registers into the sidebar.
   const descend = useCallback(async (target: WorkspaceCandidate): Promise<Project> => { const response = await authenticatedFetch(`/api/projects/${encodeURIComponent(selectedProject!.projectId)}/descend`, { method: 'POST', body: JSON.stringify({ path: target.path }) }); if (!response.ok) { const body = await response.json().catch(() => ({})) as { error?: string | { message?: string } }; const error = body.error; throw new Error(typeof error === 'string' ? error : error?.message ?? `Failed to switch to ${target.name} (${response.status})`); } return (await response.json())?.data as Project; }, [selectedProject]);
-  const allocate = useCallback(async (summary: string | null) => { let id = selectedSession ? (selectedSession.__provider === 'gjc' ? selectedSession.id : null) : currentSessionId; if (id) return id; const target = workspaceTarget.isWorkspace ? workspaceTarget.target : null; const project = target ? await descend(target) : selectedProject; const response = await authenticatedFetch('/api/providers/sessions', { method: 'POST', body: JSON.stringify({ provider: 'gjc', projectPath: project?.fullPath || project?.path || '' }) }); if (!response.ok) throw new Error(`Failed to create session (${response.status})`); id = (await response.json())?.data?.sessionId || null; if (!id) throw new Error('no session id returned.'); onSessionEstablished?.(id, { provider: 'gjc', project: project!, summary }); return id; }, [currentSessionId, descend, onSessionEstablished, selectedProject, selectedSession, workspaceTarget.isWorkspace, workspaceTarget.target]);
+  const allocate = useCallback(async (summary: string | null, text: string) => { let id = selectedSession ? (selectedSession.__provider === 'gjc' ? selectedSession.id : null) : currentSessionId; if (id) return id; const target = await resolveForSend(text); const project = target ? await descend(target) : selectedProject; const response = await authenticatedFetch('/api/providers/sessions', { method: 'POST', body: JSON.stringify({ provider: 'gjc', projectPath: project?.fullPath || project?.path || '' }) }); if (!response.ok) throw new Error(`Failed to create session (${response.status})`); id = (await response.json())?.data?.sessionId || null; if (!id) throw new Error('no session id returned.'); onSessionEstablished?.(id, { provider: 'gjc', project: project!, summary }); return id; }, [currentSessionId, descend, onSessionEstablished, resolveForSend, selectedProject, selectedSession]);
 
   const handleSubmit = useCallback(async (event: FormEvent<HTMLFormElement> | MouseEvent | TouchEvent | KeyboardEvent<HTMLTextAreaElement>) => {
     event.preventDefault(); const text = inputRef.current; if (!text.trim() || !selectedProject) return;
@@ -126,7 +127,7 @@ export function useChatComposerState(args: UseChatComposerStateArgs) {
     const candidate = text.trimEnd(); const help = candidate.trim().toLowerCase() === 'help';
     if (candidate.startsWith('/') || help) { const gap = candidate.indexOf(' '); const name = help ? '/help' : gap > 0 ? candidate.slice(0, gap) : candidate; const commandArgs = gap > 0 ? candidate.slice(gap).trim() : ''; const app = findAppUiCommand(resolveCommandAlias(name)); if (app && (app.interceptWithArgs !== false || !commandArgs)) { clearComposer(); applyAppCommand(app); return; } const notice = getLocalCommandNotice(name, commandArgs); if (notice) { clearComposer(); addMessage({ type: 'assistant', content: notice, timestamp: Date.now() }); return; } if (!bypassGate.current) { const gate = gateForCommand(resolveCommandAlias(name), commandArgs); if (gate) { clearComposer(); announceGate({ ...gate, text: candidate }); return; } } bypassGate.current = false; const registered = slashCommands.find((item) => item.name === name); if (registered && !isAppUiCommand(registered) && registered.type !== 'skill' && registered.type !== 'provider') { void executeCommand(registered, help ? '/help' : candidate); clearComposer(); return; } }
     let images: unknown[]; try { images = await upload(attachedImages); } catch (error) { const message = error instanceof Error ? error.message : 'Unknown error'; console.error('Image upload failed:', error); addMessage({ type: 'error', content: `Failed to upload images: ${message}`, timestamp: new Date() }); return; }
-    const summary = sessionLabel(selectedSession, text); let id: string; try { id = await allocate(summary); } catch (error) { const message = error instanceof Error ? error.message : 'Unknown error'; console.error('Session creation failed:', error); addMessage({ type: 'error', content: `Failed to start a new session: ${message}`, timestamp: new Date() }); return; }
+    const summary = sessionLabel(selectedSession, text); let id: string; try { id = await allocate(summary, text); } catch (error) { const message = error instanceof Error ? error.message : 'Unknown error'; console.error('Session creation failed:', error); addMessage({ type: 'error', content: `Failed to start a new session: ${message}`, timestamp: new Date() }); return; }
     addMessage({ type: 'user', content: text, images: images as any, timestamp: new Date() }); onSessionProcessing?.(id, { statusText: null, canInterrupt: true }); setIsUserScrolledUp(false); setTimeout(scrollToBottom, 100); sendMessage({ type: 'chat.send', sessionId: id, content: text, options: { ...optionsFor(text), images } }); clearComposer(); eraseDraft(id);
   }, [addMessage, allocate, announceGate, applyAppCommand, attachedImages, clearComposer, conversation, eraseDraft, executeCommand, isLoading, login, onSessionProcessing, optionsFor, resetCommandMenuState, scrollToBottom, selectedProject, selectedSession, sendMessage, setIsUserScrolledUp, slashCommands, upload]);
   useEffect(() => { submitRef.current = handleSubmit; }, [handleSubmit]);

src/components/chat/hooks/useWorkspaceTarget.dom.bun.test.tsx

@@ -154,3 +154,62 @@ test('establishing a session releases the pin', async () => {
     fetch.restore();
   }
 });
+
+test('resolveForSend authoritatively resolves submitted text before preview completes', async () => {
+  const fetch = installFetch(({ url }) => {
+    const text = new URL(url, 'http://local').searchParams.get('text') ?? '';
+    return { isWorkspace: true, candidates: text ? [candidateA] : [] };
+  });
+  try {
+    const view = composer();
+    const target = await view.result.current.resolveForSend('exact submitted text');
+    assert.equal(target?.name, 'repo-a');
+    assert.equal(new URL(fetch.calls[1].url, 'http://local').searchParams.get('text'), 'exact submitted text');
+    assert.equal(view.result.current.isWorkspace, false);
+  } finally {
+    fetch.restore();
+  }
+});
+
+test('resolveForSend honors a pinned root target without fetching', async () => {
+  const fetch = installFetch(() => ({ isWorkspace: true, candidates: [] }));
+  try {
+    const view = composer();
+    await waitFor(() => assert.equal(fetch.calls.length, 1));
+    act(() => { view.result.current.pickTarget(null); });
+    assert.equal(await view.result.current.resolveForSend('repo-a'), null);
+    assert.equal(fetch.calls.length, 1);
+  } finally {
+    fetch.restore();
+  }
+});
+
+test('resolveForSend throws on an unsuccessful response', async () => {
+  const original = globalThis.fetch;
+  globalThis.fetch = (async () => new Response('', { status: 503 })) as typeof fetch;
+  try {
+    const view = composer();
+    await assert.rejects(() => view.result.current.resolveForSend('repo-a'), /503/);
+  } finally {
+    globalThis.fetch = original;
+  }
+});
+
+test('a late response from a previous project cannot overwrite the current project', async () => {
+  const original = globalThis.fetch;
+  let resolveA: ((response: Response) => void) | undefined;
+  globalThis.fetch = ((input: RequestInfo | URL) => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url;
+    if (url.includes('proj-workspace')) return new Promise<Response>((resolve) => { resolveA = resolve; });
+    return Promise.resolve(new Response(JSON.stringify({ data: { isWorkspace: true, candidates: [candidateB] } }), { status: 200 }));
+  }) as typeof fetch;
+  try {
+    const view = composer();
+    view.rerender({ selectedProject: { ...project, projectId: 'proj-b' } });
+    await waitFor(() => assert.equal(view.result.current.candidates[0]?.name, 'repo-b'));
+    await act(async () => { resolveA?.(new Response(JSON.stringify({ data: { isWorkspace: true, candidates: [candidateA] } }), { status: 200 })); });
+    assert.equal(view.result.current.candidates[0]?.name, 'repo-b');
+  } finally {
+    globalThis.fetch = original;
+  }
+});

src/components/chat/hooks/useWorkspaceTarget.ts

@@ -27,11 +27,13 @@ interface UseWorkspaceTargetResult {
   pickTarget: (candidate: WorkspaceCandidate | null) => void;
   /** True once the user has made an explicit pick that later typing must not override. */
   pinned: boolean;
+  resolveForSend: (text: string) => Promise<WorkspaceCandidate | null>;
 }
 
 /** A resolved candidate strong enough to auto-target without the user picking it. */
 const AUTO_TARGET_SCORE = 80;
 const RESOLVE_DEBOUNCE_MS = 300;
+const RESOLVE_TEXT_MAX = 2000;
 
 /**
  * Resolves, for a new task started in a workspace-root project (e.g.
@@ -55,22 +57,35 @@ export function useWorkspaceTarget({ selectedProject, selectedSession, currentSe
 
   const resolve = useCallback(async (text: string) => {
     if (!projectId) return;
-    latestRequest.current = text;
+    const cappedText = text.slice(0, RESOLVE_TEXT_MAX);
+    const request = `${projectId}\n${cappedText}`;
+    latestRequest.current = request;
     try {
-      const response = await authenticatedFetch(`/api/projects/${encodeURIComponent(projectId)}/resolve-target?text=${encodeURIComponent(text)}`);
-      if (latestRequest.current !== text) return;
+      const response = await authenticatedFetch(`/api/projects/${encodeURIComponent(projectId)}/resolve-target?text=${encodeURIComponent(cappedText)}`);
+      if (latestRequest.current !== request) return;
       if (!response.ok) { setIsWorkspace(false); setCandidates([]); return; }
       const body = await response.json();
-      if (latestRequest.current !== text) return;
+      if (latestRequest.current !== request) return;
       setIsWorkspace(Boolean(body?.data?.isWorkspace));
       setCandidates(Array.isArray(body?.data?.candidates) ? body.data.candidates : []);
     } catch {
-      if (latestRequest.current !== text) return;
+      if (latestRequest.current !== request) return;
       setIsWorkspace(false);
       setCandidates([]);
     }
   }, [projectId]);
 
+  const resolveForSend = useCallback(async (text: string): Promise<WorkspaceCandidate | null> => {
+    if (!projectId || pinned) return pinnedTarget;
+    const cappedText = text.slice(0, RESOLVE_TEXT_MAX);
+    const response = await authenticatedFetch(`/api/projects/${encodeURIComponent(projectId)}/resolve-target?text=${encodeURIComponent(cappedText)}`);
+    if (!response.ok) throw new Error(`Failed to resolve workspace target (${response.status})`);
+    const body = await response.json();
+    if (!body?.data?.isWorkspace) return null;
+    const candidates = Array.isArray(body?.data?.candidates) ? body.data.candidates as WorkspaceCandidate[] : [];
+    return candidates.length && candidates[0].score >= AUTO_TARGET_SCORE ? candidates[0] : null;
+  }, [pinned, pinnedTarget, projectId]);
+
   // The empty-text probe: once per new-task mount/project change, tells the
   // composer whether there is anything to resolve at all.
   useEffect(() => {
@@ -99,6 +114,11 @@ export function useWorkspaceTarget({ selectedProject, selectedSession, currentSe
     }
   }, [currentSessionId, input, selectedSession]);
 
+  useEffect(() => {
+    setPinned(false);
+    setPinnedTarget(null);
+  }, [projectId]);
+
   const pickTarget = useCallback((candidate: WorkspaceCandidate | null) => {
     setPinnedTarget(candidate);
     setPinned(true);
@@ -107,5 +127,5 @@ export function useWorkspaceTarget({ selectedProject, selectedSession, currentSe
   const autoTarget = candidates.length > 0 && candidates[0].score >= AUTO_TARGET_SCORE ? candidates[0] : null;
   const target = pinned ? pinnedTarget : autoTarget;
 
-  return { isWorkspace, candidates, target, pickTarget, pinned };
+  return { isWorkspace, candidates, target, pickTarget, pinned, resolveForSend };
 }

src/hooks/useProjectsState.query.dom.bun.test.tsx

@@ -202,6 +202,26 @@ test('an upsert carrying an origin promotes the cached project so the sidebar ca
   }
 });
 
+test('upsert origin only promotes cached projects to explicit', async () => {
+  const fetch = installFetch([{ body: [{ ...project(), origin: 'explicit' }] }]);
+  try {
+    const harness = renderHarness();
+    await waitFor(() => assert.equal(harness.getState().projects.length, 1));
+    act(() => harness.emit({
+      kind: 'session_upserted', sessionId: 'auto-event', provider: 'gjc', session: { id: 'auto-event' },
+      project: { ...project(), origin: 'auto' }, timestamp: new Date().toISOString(),
+    } as ServerEvent));
+    await waitFor(() => assert.equal(harness.getState().projects[0]?.origin, 'explicit'));
+    act(() => harness.emit({
+      kind: 'session_upserted', sessionId: 'explicit-event', provider: 'gjc', session: { id: 'explicit-event' },
+      project: { ...project(), origin: 'explicit' }, timestamp: new Date().toISOString(),
+    } as ServerEvent));
+    assert.equal(harness.getState().projects[0]?.origin, 'explicit');
+  } finally {
+    fetch.restore();
+  }
+});
+
 test('an upsert for the viewed session renames it where the header reads it, not only in the sidebar', async () => {
   const fetch = installFetch([{ body: [project()] }]);
   try {

src/hooks/useProjectsState.ts

@@ -99,11 +99,10 @@ const updateProjectCache = (projects: Project[], event: SessionUpsert): Project[
     ? project.projectId === projectId
     : rowsOf(project).some((session) => session.id === event.sessionId));
   if (found) {
-    // A row the indexer discovered ('auto') can become a sidebar project the
-    // moment a session lands in it (a workspace descend promotes it), so the
-    // event's origin wins over the cached one.
+    // The database only promotes discovered rows ('auto'/'legacy') to explicit;
+    // a later index event must never demote an explicit cached project.
     const origin = event.project?.origin;
-    const promoted = origin && origin !== found.origin ? { ...found, origin } : found;
+    const promoted = origin === 'explicit' && found.origin !== 'explicit' ? { ...found, origin } : found;
     const next = applySessionUpsert(promoted, event);
     return next === found ? projects : projects.map((project) => project === found ? next : project);
   }