Bohdan Triapitsyn
edfc9779cf
Switching sessions ran as one synchronous commit: sidebar highlight, URL, a full timeline remount with markdown re-parse, and around nine requests, so nothing changed on screen for 150-250ms after the click. - ChatContainer swaps the timeline on a deferred copy of the selection, so the active row, URL, and tab commit first and the timeline renders behind them; selection policy keeps reading the live store value. - The message fetch starts before the selection is published. - Sidebar rows stop re-rendering on a project switch: directory-scoped sync hooks read the runtime context and a subscribable current-directory source instead of the directory-bearing context; the grouping builder reads git branches through a ref and section caches key the branches they use; descendant ids are keyed by content. Rows per switch went from 73 to 8. - Markdown skips the async re-render when the settled cached blocks are already painted, and mounts synchronously once its lazy module is loaded; the module is preloaded at boot. - A timeline reveal gate holds a freshly opened session at opacity 0 while any provisional markdown paint catches up (250ms cap), then fades the whole timeline in once, so text, tools, and recap appear together. - Switch fan-out trimmed: knowledge summary deduped, MCP status refreshed only when stale, non-repo directories cached by the git repo check, OpenChamber defaults cached briefly, agent memory reused for the same project, goal text cached, PWA manifest rebuilt after the switch settles. - Header tabs snap into the active state and keep the title at the same height in both states. - Prefetch on row press; composer focus moved off the commit. `bun run profile:switch` records ack/content latency, longest task, and requests per switch, cold and warm, and compares runs against a baseline. Measured warm switch: ack 228ms to about 40-60ms, content 228ms to about 100-120ms.
60 lines
2.3 KiB
TypeScript
60 lines
2.3 KiB
TypeScript
/**
|
|
* Keeps agent memory loaded for whatever project the session belongs to.
|
|
*
|
|
* This does not belong to the Memory tab. The session index is built from the
|
|
* loaded snapshot, so leaving the load to the panel meant a user who never
|
|
* opened Project notes sent every message with no memory index at all — the
|
|
* agent had memories it was never told about.
|
|
*
|
|
* The session directory is resolved to its project first. A session in a
|
|
* worktree has the worktree's path, and loading by that path reads a store the
|
|
* agent does not write to, which is the same mismatch in the other direction.
|
|
*/
|
|
|
|
import React from 'react';
|
|
|
|
import { subscribeOpenchamberEvents } from '@/lib/openchamberEvents';
|
|
import { useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
|
|
import { useUIStore } from '@/stores/useUIStore';
|
|
import { useProjectContextOwner } from '@/hooks/useProjectContextOwner';
|
|
|
|
/**
|
|
* The directory is a parameter rather than read from `useEffectiveDirectory`,
|
|
* because this runs above `SyncProvider` — that hook reads the sync context and
|
|
* throws outside it, which took the whole app down with a blank window.
|
|
*/
|
|
const AGENT_MEMORY_FRESH_MS = 60_000;
|
|
|
|
export const useAgentMemorySync = (directory: string | null): void => {
|
|
const enabled = useUIStore((state) => (
|
|
state.agentMemoryFeatureAvailable && state.agentMemoryToolEnabled
|
|
));
|
|
const load = useAgentMemoryStore((state) => state.load);
|
|
const owner = useProjectContextOwner(directory);
|
|
const projectPath = owner?.path ?? null;
|
|
|
|
// The owner re-resolves on every directory switch; entries loaded moments
|
|
// ago for the same project are still current, and the change event below
|
|
// forces a re-read when the agent writes memory.
|
|
React.useEffect(() => {
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
void load(projectPath, { maxAgeMs: AGENT_MEMORY_FRESH_MS });
|
|
}, [enabled, load, projectPath]);
|
|
|
|
// The agent writes memory mid-turn through its own tool, so the index for the
|
|
// next message has to come from a fresh read rather than the snapshot taken
|
|
// before the turn started.
|
|
React.useEffect(() => {
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
return subscribeOpenchamberEvents((event) => {
|
|
if (event.type === 'agent-memory-changed') {
|
|
void load(projectPath);
|
|
}
|
|
});
|
|
}, [enabled, load, projectPath]);
|
|
};
|