diff --git a/public/style.css b/public/style.css
index 1566575..5453a66 100644
--- a/public/style.css
+++ b/public/style.css
@@ -2606,6 +2606,26 @@ html[data-theme='wasteland'] .advanced-search-panel {
color: var(--text-muted);
font-size: 12px;
}
+.user-outline-loading {
+ width: 100%;
+ padding: 8px 10px;
+ border: 0;
+ background: transparent;
+ color: var(--text-muted);
+ font: inherit;
+ font-size: 12px;
+ line-height: 1.45;
+ text-align: left;
+}
+.user-outline-retry {
+ color: var(--accent);
+ cursor: pointer;
+}
+.user-outline-retry:hover,
+.user-outline-retry:focus-visible {
+ background: var(--accent-light);
+ outline: none;
+}
.user-outline-item {
width: 100%;
display: grid;
@@ -2723,21 +2743,21 @@ html[data-theme='wasteland'] .advanced-search-panel {
/* === Messages === */
.messages-wrap {
flex: 1;
+ display: flex;
+ flex-direction: column;
position: relative;
overflow: hidden;
min-height: 0;
}
.history-load-more {
- position: absolute;
- z-index: 3;
- top: 10px;
- left: 50%;
+ flex: 0 0 auto;
+ align-self: center;
display: inline-flex;
align-items: center;
gap: 10px;
max-width: min(92%, 560px);
+ margin: 0 auto 10px;
padding: 7px 10px 7px 12px;
- transform: translateX(-50%);
border: 1px solid color-mix(in srgb, var(--accent) 28%, var(--border-color));
border-radius: 999px;
background: color-mix(in srgb, var(--bg-secondary) 92%, transparent);
@@ -2745,7 +2765,6 @@ html[data-theme='wasteland'] .advanced-search-panel {
color: var(--text-secondary);
font-size: 12px;
line-height: 1.35;
- backdrop-filter: blur(12px);
}
.history-load-more-copy {
overflow: hidden;
@@ -2779,7 +2798,9 @@ html[data-theme='wasteland'] .advanced-search-panel {
color: var(--danger);
}
.messages {
- height: 100%;
+ flex: 1;
+ min-height: 0;
+ height: auto;
overflow-y: scroll;
overflow-x: hidden;
padding: 16px;
diff --git a/scripts/regression.js b/scripts/regression.js
index c758dc0..7f1c422 100644
--- a/scripts/regression.js
+++ b/scripts/regression.js
@@ -671,7 +671,7 @@ function assertFrontendSidebarCollapseContract() {
'Rich themes should provide isolated rail treatments on top of the shared semantic fallback'
);
assert(
- indexSource.includes('style.css?v=20260911-file-suggestion')
+ indexSource.includes('style.css?v=20260913-history-control-position')
&& indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'),
'Sidebar interaction assets should share the reviewed cache-busting version'
);
@@ -1190,7 +1190,7 @@ function assertPlanListProgressContract() {
assert(extractorSource.includes('references/source-assets/wasteland-icon-sheet.webp'), 'Plan progress extractor should read the archived source sheet');
assert(!extractorSource.includes('sessions/_attachments'), 'Plan progress extractor should not depend on temporary session attachments');
- assert(indexSource.includes('style.css?v=20260911-file-suggestion'), 'Plan progress CSS should use the current cache-busted URL');
+ assert(indexSource.includes('style.css?v=20260913-history-control-position'), 'Plan progress CSS should use the current cache-busted URL');
assert(indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'), 'Plan progress frontend logic should use the dynamic cache-busted URL');
}
@@ -1306,7 +1306,7 @@ function assertFrontendGildedThemeContract() {
assert(contrast('#655446', '#fff7ea') >= 4.5, 'Gilded muted text should remain readable on ivory panels');
assert(contrast('#fff7ea', '#7a3f20') >= 7, 'Gilded primary action text should reach AAA contrast on copper');
assert(themeStyle.includes('@media (prefers-reduced-motion: reduce)'), 'Gilded theme motion should respect reduced-motion preferences');
- assert(indexSource.includes('style.css?v=20260911-file-suggestion'), 'Theme bundle stylesheet should use the current cache-busted asset URL');
+ assert(indexSource.includes('style.css?v=20260913-history-control-position'), 'Theme bundle stylesheet should use the current cache-busted asset URL');
assert(indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'), 'Theme bundle app script should use the dynamic cache-busted asset URL');
}
@@ -1560,7 +1560,7 @@ function assertFrontendWastelandThemeContract() {
assert(contrast('#c9bda6', backgroundColor) >= 4.5, `Wasteland muted text should reach AA contrast on ${backgroundColor}`);
});
- assert(indexSource.includes('style.css?v=20260911-file-suggestion'), 'Wasteland stylesheet should share the cache-busted theme bundle URL');
+ assert(indexSource.includes('style.css?v=20260913-history-control-position'), 'Wasteland stylesheet should share the cache-busted theme bundle URL');
assert(indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'), 'Wasteland registration should share the dynamic cache-busted theme bundle URL');
}
@@ -2616,7 +2616,7 @@ function assertGoalModeTitleContract() {
assert(styleSource.includes('.msg.user.goal-message .msg-bubble'), 'Goal label styling should remain scoped to user Goal bubbles');
assert(styleSource.includes('.goal-message-label'), 'Goal mode label should have a dedicated style');
assert(styleSource.includes("html[data-theme='wasteland'] .msg.user.goal-message .goal-message-label"), 'Wasteland should provide a dedicated Goal label treatment');
- assert(indexSource.includes('style.css?v=20260911-file-suggestion'), 'Goal label CSS should use the current cache-busted URL');
+ assert(indexSource.includes('style.css?v=20260913-history-control-position'), 'Goal label CSS should use the current cache-busted URL');
assert(serverSource.includes('GOAL_DERIVED_TITLE_MAX_CHARS = 60'), 'Goal-derived titles should keep the 60-character limit');
assert(serverSource.includes('function isDefaultConversationTitle(session)'), 'Goal title updates should use a default-title guard');
assert(serverSource.includes('function applyDerivedGoalConversationTitle(session, objective)'), 'Goal title updates should stay in the /goal-specific server path');
@@ -3525,6 +3525,27 @@ function assertSessionSwitchResilienceContract() {
const runtimeSource = fs.readFileSync(path.join(REPO_DIR, 'lib', 'agent-runtime.js'), 'utf8');
assert(frontendSource.includes('SESSION_LOAD_REQUEST_TIMEOUT_MS'), 'Frontend should define a hard timeout for session load requests');
+ assert(
+ frontendSource.includes('msg.features?.clientHeartbeat === true')
+ && frontendSource.includes('!wsSupportsClientHeartbeat'),
+ 'Frontend should only send application heartbeats when the server advertises support'
+ );
+ assert(
+ frontendSource.includes('let activeAssigned = false')
+ && frontendSource.includes("el.classList.toggle('active', isActive)"),
+ 'Sidebar highlighting should keep at most one active session row'
+ );
+ assert(
+ /Unknown type:\\s\*client_heartbeat/.test(frontendSource),
+ 'Frontend should ignore the legacy server heartbeat compatibility error'
+ );
+ assert(
+ frontendSource.includes('WS_CLIENT_HEARTBEAT_INTERVAL_MS')
+ && frontendSource.includes('function startWsHeartbeat')
+ && frontendSource.includes("type: 'client_heartbeat'")
+ && frontendSource.includes("case 'client_heartbeat_ack':"),
+ 'Frontend should actively detect an OPEN-but-stale WebSocket before session load timeout'
+ );
assert(frontendSource.includes('sessionLoadRequestTimer'), 'Frontend should track the session load request timeout timer');
assert(frontendSource.includes('function clearPendingSessionSwitchRequest'), 'Frontend should be able to cancel stale pending session switch requests');
assert(frontendSource.includes('function scheduleSessionLoadRequestTimeout'), 'Frontend should schedule cancellation for stuck load_session requests');
@@ -3594,6 +3615,14 @@ function assertSessionSwitchResilienceContract() {
assert(serverSource.includes('SESSION_TRANSPORT_MESSAGE_CONTENT_MAX_CHARS'), 'Server should cap session message size for WebSocket transport');
assert(serverSource.includes("case 'resume_session':"), 'Server should accept lightweight resume_session requests');
+ assert(
+ /case 'client_heartbeat':\s*wsSend\(ws,\s*\{[\s\S]*?type:\s*'client_heartbeat_ack'/.test(serverSource),
+ 'Server should acknowledge the client application heartbeat'
+ );
+ assert(
+ serverSource.includes('clientHeartbeat: true'),
+ 'Server auth_result should advertise client heartbeat support'
+ );
assert(serverSource.includes('function handleResumeSession'), 'Server should implement lightweight running-session resume');
assert(serverSource.includes('function attachActiveRuntimeToWs'), 'Server should share runtime re-attach logic without sending session_info first');
assert(/case 'abort':\s*handleAbort\(ws, msg\);/.test(serverSource), 'Server should pass abort request metadata to handleAbort');
@@ -3642,6 +3671,7 @@ function assertSessionRenderEpochRaceContract() {
let collabAgentStateCache = new Map();
let collabAgentIdsByToolUseId = new Map();
let closedCollabAgentIdsByToolUseId = new Map();
+ const historyLoadMore = null;
const scheduled = [];
const messagesDiv = {
nodes: [],
@@ -3721,6 +3751,7 @@ function assertSessionRenderEpochRaceContract() {
function assertSessionRequestIdRaceContract() {
const frontendSource = fs.readFileSync(PUBLIC_APP_PATH, 'utf8');
+ const historyMergeSource = extractFunctionSource(frontendSource, 'mergeHistoryChunkIntoSessionLoadSnapshot');
const sessionInfoStart = frontendSource.indexOf("case 'session_info':");
const sessionInfoDecisionStart = frontendSource.indexOf('const messageRequestId', sessionInfoStart);
const sessionInfoDecisionEnd = frontendSource.indexOf('if (!canSwitchToSessionInfo)', sessionInfoDecisionStart);
@@ -3795,13 +3826,21 @@ function assertSessionRequestIdRaceContract() {
};
let currentSessionId = 'session-b';
let loadedHistorySessionId = 'session-b';
+ let activeOutlineHistoryRequest = null;
+ let activeOutlineTargetRequest = null;
+ const currentOutlineHistoryState = { sessionId: 'session-b', entries: new Map(), cursor: 0, total: 0, available: true };
const prepended = [];
const finalized = [];
function cloneMessages(messages) { return messages.slice(); }
function isBlockingSessionLoad() { return false; }
function prependHistoryMessages(messages) { prepended.push(...messages); }
+ function mergeOutlineHistoryMessages() {}
+ function requestOutlineHistoryPage() {}
+ function isCompleteSessionSnapshot() { return false; }
+ function bufferSessionSnapshot() {}
function scheduleAdvancedSearchJump() {}
function finalizeLoadedSession(sessionId, requestId) { finalized.push({ sessionId, requestId }); }
+ ${historyMergeSource}
function handleHistoryMessage(msg) {
switch (msg.type) {
${historyCaseSource}
@@ -3909,6 +3948,7 @@ function assertBlockingFinishRafRequestRaceContract() {
function assertRecoverCurrentHistoryMergeContract() {
const frontendSource = fs.readFileSync(PUBLIC_APP_PATH, 'utf8');
const finalizeLoadedSessionSource = extractFunctionSource(frontendSource, 'finalizeLoadedSession');
+ const historyMergeSource = extractFunctionSource(frontendSource, 'mergeHistoryChunkIntoSessionLoadSnapshot');
const historyStart = frontendSource.indexOf("case 'session_history_chunk':");
const historyEnd = frontendSource.indexOf("case 'session_message':", historyStart);
assert(historyStart >= 0 && historyEnd > historyStart, 'Frontend should keep an extractable recovery history handler');
@@ -3919,19 +3959,36 @@ function assertRecoverCurrentHistoryMergeContract() {
requestId: 'request-recover-new',
recoverCurrent: true,
blocking: false,
- snapshot: { messages: [{ id: 'recent' }] },
+ snapshot: {
+ messages: [{ id: 'recent' }],
+ historyTotal: 3,
+ historyBuffered: 1,
+ historyCursor: 2,
+ historyBaseIndex: 2,
+ historyTruncated: true,
+ historyPending: true,
+ complete: false,
+ },
};
let currentSessionId = 'session-recover';
let loadedHistorySessionId = 'session-recover';
+ let activeOutlineHistoryRequest = null;
+ let activeOutlineTargetRequest = null;
+ const currentOutlineHistoryState = { sessionId: 'session-recover', entries: new Map(), cursor: 0, total: 0, available: true };
const prepended = [];
const cached = [];
const finished = [];
function cloneMessages(messages) { return messages.map((message) => ({ ...message })); }
function isBlockingSessionLoad() { return false; }
function prependHistoryMessages(messages) { prepended.push(...messages); }
+ function mergeOutlineHistoryMessages() {}
+ function requestOutlineHistoryPage() {}
+ function isCompleteSessionSnapshot() { return false; }
+ function bufferSessionSnapshot() {}
function scheduleAdvancedSearchJump() {}
function cacheSessionSnapshot(snapshot) { cached.push(JSON.parse(JSON.stringify(snapshot))); }
function finishSessionSwitch(sessionId, requestId) { finished.push({ sessionId, requestId }); }
+ ${historyMergeSource}
${finalizeLoadedSessionSource}
function handleHistoryMessage(msg) {
switch (msg.type) {
@@ -4000,6 +4057,240 @@ function assertRecoverCurrentHistoryMergeContract() {
assert(failures.length === 0, failures.join('; '));
}
+function assertPartialSessionSnapshotCacheContract() {
+ const frontendSource = fs.readFileSync(PUBLIC_APP_PATH, 'utf8');
+ const normalizeSource = extractFunctionSource(frontendSource, 'normalizeSessionSnapshot');
+ const completeSource = extractFunctionSource(frontendSource, 'isCompleteSessionSnapshot');
+ const bufferSource = extractFunctionSource(frontendSource, 'bufferSessionSnapshot');
+ const getBufferSource = extractFunctionSource(frontendSource, 'getSessionHistoryBuffer');
+ const cacheSource = extractFunctionSource(frontendSource, 'cacheSessionSnapshot');
+ const mergeSource = extractFunctionSource(frontendSource, 'mergeHistoryChunkIntoCachedSnapshot');
+ const dispositionSource = extractFunctionSource(frontendSource, 'getSessionCacheDisposition');
+ assert(completeSource, 'Frontend should expose one session snapshot completeness predicate');
+ const api = new Function(`
+ const SESSION_CACHE_LIMIT = 8;
+ const SESSION_CACHE_MAX_WEIGHT = 1024 * 1024;
+ const sessionCache = new Map();
+ const sessionHistoryBuffers = new Map();
+ function deepClone(value) { return value === undefined ? value : JSON.parse(JSON.stringify(value)); }
+ function cloneMessages(messages) { return Array.isArray(messages) ? deepClone(messages) : []; }
+ function normalizeOutlineTitleHistory(history) { return Array.isArray(history) ? history : []; }
+ function normalizeAgent(agent) { return String(agent || 'codexapp'); }
+ function normalizeGiteaSource(source) { return source || null; }
+ function estimateSessionSnapshotWeight() { return 1; }
+ function getSessionMeta() {
+ return { updated: '2026-09-13T00:00:00.000Z', hasUnread: false, isRunning: false, waitingOnChildren: false };
+ }
+ function pruneSessionCache() {}
+ ${normalizeSource}
+ ${completeSource}
+ ${bufferSource}
+ ${getBufferSource}
+ ${cacheSource}
+ ${mergeSource}
+ ${dispositionSource}
+ return {
+ normalizeSessionSnapshot,
+ isCompleteSessionSnapshot,
+ bufferSessionSnapshot,
+ cacheSessionSnapshot,
+ mergeHistoryChunkIntoCachedSnapshot,
+ getSessionCacheDisposition,
+ cacheSize: () => sessionCache.size,
+ bufferSize: () => sessionHistoryBuffers.size,
+ };
+ `)();
+
+ const partial = api.normalizeSessionSnapshot({
+ sessionId: 'partial-history',
+ messages: Array.from({ length: 12 }, (_, index) => ({ id: `recent-${index}` })),
+ historyTotal: 99,
+ historyBuffered: 12,
+ historyCursor: 87,
+ historyBaseIndex: 87,
+ historyTruncated: true,
+ historyPending: false,
+ });
+ assert(partial.complete === false, 'A truncated session_info snapshot must not be marked complete');
+ assert(api.isCompleteSessionSnapshot(partial) === false,
+ 'A snapshot with historyCursor>0 must fail the complete-history predicate');
+ api.cacheSessionSnapshot(partial);
+ assert(api.cacheSize() === 0, 'Partial history must never enter the session cache');
+
+ const paged = api.normalizeSessionSnapshot({
+ sessionId: 'paged-history',
+ messages: [{ id: 'paged-recent' }],
+ historyTotal: 3,
+ historyBuffered: 1,
+ historyCursor: 2,
+ historyBaseIndex: 2,
+ historyTruncated: true,
+ historyPending: false,
+ updated: '2026-09-13T00:00:00.000Z',
+ });
+ api.bufferSessionSnapshot(paged);
+ assert(api.getSessionCacheDisposition('paged-history') === 'miss'
+ && api.bufferSize() === 1,
+ 'Partial history should stay out of strong cache while remaining available for pagination');
+ api.mergeHistoryChunkIntoCachedSnapshot('paged-history', [{ id: 'paged-middle' }], {
+ baseIndex: 1,
+ cursor: 1,
+ total: 3,
+ });
+ api.mergeHistoryChunkIntoCachedSnapshot('paged-history', [{ id: 'paged-oldest' }], {
+ baseIndex: 0,
+ cursor: 0,
+ total: 3,
+ });
+ assert(api.getSessionCacheDisposition('paged-history') === 'strong'
+ && api.cacheSize() === 1
+ && api.bufferSize() === 0,
+ 'The final paged history chunk should promote the merged snapshot to strong cache');
+
+ const forcedPartial = api.normalizeSessionSnapshot({
+ sessionId: 'forced-partial-history',
+ messages: [{ id: 'recent-only' }],
+ historyTotal: 10,
+ historyBuffered: 1,
+ historyCursor: 9,
+ historyBaseIndex: 9,
+ historyPending: false,
+ }, { complete: true });
+ assert(forcedPartial.complete === false,
+ 'Callers must not be able to force a partial snapshot to complete');
+
+ const legacyBadCache = {
+ sessionId: 'legacy-bad-cache',
+ complete: true,
+ historyPending: false,
+ historyCursor: 0,
+ historyBaseIndex: 5,
+ historyTruncated: false,
+ historyBuffered: 10,
+ historyTotal: 10,
+ messages: Array.from({ length: 10 }, (_, index) => ({ id: `legacy-${index}` })),
+ };
+ assert(api.isCompleteSessionSnapshot(legacyBadCache) === false,
+ 'A legacy cache with non-zero historyBaseIndex must be treated as incomplete');
+ api.cacheSessionSnapshot(legacyBadCache);
+ assert(api.cacheSize() === 1 && api.getSessionCacheDisposition('legacy-bad-cache') === 'miss',
+ 'Legacy partial cache entries must not become strong cache hits');
+
+ const cacheSizeBeforeComplete = api.cacheSize();
+ const complete = api.normalizeSessionSnapshot({
+ sessionId: 'complete-history',
+ messages: Array.from({ length: 12 }, (_, index) => ({ id: `message-${index}` })),
+ historyTotal: 12,
+ historyBuffered: 12,
+ historyCursor: 0,
+ historyBaseIndex: 0,
+ historyTruncated: false,
+ historyPending: false,
+ updated: '2026-09-13T00:00:00.000Z',
+ });
+ assert(complete.complete === true, 'A fully buffered session snapshot should be marked complete');
+ api.cacheSessionSnapshot(complete);
+ assert(api.cacheSize() === cacheSizeBeforeComplete + 1,
+ 'A complete session snapshot should enter the session cache');
+ assert(api.getSessionCacheDisposition('complete-history') === 'strong',
+ 'A complete unchanged snapshot should remain a strong cache hit');
+}
+
+function assertSessionSwitchCacheBehaviorContract() {
+ const frontendSource = fs.readFileSync(PUBLIC_APP_PATH, 'utf8');
+ const completeSource = extractFunctionSource(frontendSource, 'isCompleteSessionSnapshot');
+ const dispositionSource = extractFunctionSource(frontendSource, 'getSessionCacheDisposition');
+ const openSource = extractFunctionSource(frontendSource, 'openSession');
+ const api = new Function(`
+ const sessionCache = new Map();
+ const metas = new Map([
+ ['session-a', { id: 'session-a', agent: 'codexapp', updated: 'v1', hasUnread: false, isRunning: false, waitingOnChildren: false }],
+ ['session-b', { id: 'session-b', agent: 'codexapp', updated: 'v1', hasUnread: false, isRunning: false, waitingOnChildren: false }],
+ ]);
+ let currentSessionId = 'session-b';
+ let activeSessionLoad = null;
+ const loads = [];
+ const shown = [];
+ const taskBoardViewState = { open: false };
+ const usageDashboardState = { open: false };
+ function isCompleteSessionSnapshot(snapshot) {
+ if (!snapshot || snapshot.complete !== true || snapshot.historyPending || snapshot.historyTruncated) return false;
+ const historyTotal = Number.isFinite(Number(snapshot.historyTotal)) ? Math.max(0, Number(snapshot.historyTotal)) : (snapshot.messages || []).length;
+ const historyBuffered = Number.isFinite(Number(snapshot.historyBuffered)) ? Math.max(0, Number(snapshot.historyBuffered)) : (snapshot.messages || []).length;
+ const historyCursor = Number.isFinite(Number(snapshot.historyCursor)) ? Math.max(0, Number(snapshot.historyCursor)) : 0;
+ const historyBaseIndex = Number.isFinite(Number(snapshot.historyBaseIndex)) ? Math.max(0, Number(snapshot.historyBaseIndex)) : 0;
+ return historyCursor === 0 && historyBaseIndex === 0 && historyBuffered >= historyTotal;
+ }
+ function getSessionMeta(sessionId) { return metas.get(sessionId) || null; }
+ function normalizeAgent(agent) { return String(agent || 'codexapp'); }
+ function getSessionCacheDisposition(sessionId) {
+ const entry = sessionCache.get(sessionId);
+ const meta = getSessionMeta(sessionId);
+ if (!entry?.snapshot || !isCompleteSessionSnapshot(entry.snapshot) || !meta) {
+ if (entry && !isCompleteSessionSnapshot(entry.snapshot)) sessionCache.delete(sessionId);
+ return 'miss';
+ }
+ if (entry.version === (meta.updated || null) && !meta.hasUnread && !meta.isRunning && !meta.waitingOnChildren) return 'strong';
+ return 'weak';
+ }
+ function closeTaskBoard() {}
+ function closeUsageDashboard() {}
+ function isPrimaryUiAgent() { return true; }
+ function renderSessionList() {}
+ function closeUserOutlinePanel() {}
+ function closeCcwebPromptOutlinePanel() {}
+ function beginSessionSwitch(sessionId) { loads.push(sessionId); }
+ function showCachedSession(sessionId) { shown.push(sessionId); return true; }
+ ${openSource}
+ return {
+ openSession,
+ put(id, snapshot) { sessionCache.set(id, { snapshot, version: snapshot.updated || null }); },
+ setCurrent(id) { currentSessionId = id; activeSessionLoad = null; },
+ loads,
+ shown,
+ hasCache(id) { return sessionCache.has(id); },
+ };
+ `)();
+
+ api.openSession('session-a');
+ assert(JSON.stringify(api.loads) === JSON.stringify(['session-a']) && api.shown.length === 0,
+ 'A session without a complete cache must issue a new load_session request');
+
+ api.put('session-a', {
+ sessionId: 'session-a',
+ complete: true,
+ historyPending: false,
+ historyCursor: 0,
+ historyBaseIndex: 0,
+ historyTruncated: false,
+ historyBuffered: 2,
+ historyTotal: 2,
+ updated: 'v1',
+ messages: [{ id: 'user-a' }, { id: 'assistant-a' }],
+ });
+ api.setCurrent('session-b');
+ api.openSession('session-a');
+ assert(api.shown.length === 1 && api.loads.length === 1,
+ 'A complete unchanged snapshot may be reused without another load');
+
+ api.put('session-a', {
+ sessionId: 'session-a',
+ complete: true,
+ historyPending: false,
+ historyCursor: 0,
+ historyBaseIndex: 5,
+ historyTruncated: false,
+ historyBuffered: 2,
+ historyTotal: 2,
+ updated: 'v1',
+ messages: [{ id: 'recent-only' }],
+ });
+ api.setCurrent('session-b');
+ api.openSession('session-a');
+ assert(api.loads.length === 2 && api.shown.length === 1 && !api.hasCache('session-a'),
+ 'A legacy partial cache must be discarded and must not hide user messages on return');
+}
+
function assertServerSessionHistoryRequestIdContract() {
const serverSource = fs.readFileSync(SERVER_PATH, 'utf8');
const handleLoadSessionSource = extractFunctionSource(serverSource, 'handleLoadSession');
@@ -4089,6 +4380,11 @@ function assertHistoryRecallContract() {
const styleSource = fs.readFileSync(PUBLIC_STYLE_PATH, 'utf8');
assert(indexSource.includes('id="history-load-more"'), 'Chat view should expose a history load-more control');
+ assert(
+ /
\s*
]*>\s*
0[\s\S]*?historyState\.available/.test(frontendSource),
+ 'Locator button should remain openable when only older user messages are available');
+ assert(
+ /messagesDiv\.innerHTML = '';\s*if \(historyLoadMore\) messagesDiv\.appendChild\(historyLoadMore\)/.test(frontendSource),
+ 'Message rerenders should preserve the in-content history control');
+ assert(
+ /messagesDiv\.insertBefore\(frag, historyLoadMore\?\.nextSibling \|\| null\)/.test(frontendSource),
+ 'Older message batches should be inserted below the in-content history control');
+ const historyHandlerStart = frontendSource.indexOf("case 'session_history_chunk':");
+ const historyHandlerEnd = frontendSource.indexOf("case 'session_message':", historyHandlerStart);
+ const historyHandlerSource = historyHandlerStart >= 0 && historyHandlerEnd > historyHandlerStart
+ ? frontendSource.slice(historyHandlerStart, historyHandlerEnd)
+ : '';
+ assert(
+ /matchesOutlineTargetLoad[\s\S]*?prependHistoryMessages[\s\S]*?mergeOutlineHistoryMessages/.test(historyHandlerSource),
+ 'Locator target pages should render only the requested page and update the independent index');
+ assert(
+ historyHandlerSource.indexOf('if (matchesOutlineTargetLoad)') >= 0
+ && historyHandlerSource.indexOf('if (matchesOutlineHistoryLoad)') > historyHandlerSource.indexOf('if (matchesOutlineTargetLoad)'),
+ 'Locator target-page handling should run before the full locator-page path');
+ const outlineHistoryBranchStart = historyHandlerSource.indexOf('if (matchesOutlineHistoryLoad)');
+ const outlineHistoryBranchEnd = historyHandlerSource.indexOf('if (activeSessionLoad?.recoverCurrent', outlineHistoryBranchStart);
+ const outlineHistoryBranch = outlineHistoryBranchStart >= 0 && outlineHistoryBranchEnd > outlineHistoryBranchStart
+ ? historyHandlerSource.slice(outlineHistoryBranchStart, outlineHistoryBranchEnd)
+ : '';
+ assert(
+ outlineHistoryBranch && !outlineHistoryBranch.includes('prependHistoryMessages'),
+ 'Full locator history pages must stay in the independent index and out of the chat DOM');
+ assert(
+ /matchesOutlineHistoryLoad[\s\S]*?prependHistoryMessages/.test(frontendSource),
+ 'Ordinary history pages should still prepend into the chat when explicitly requested');
+ assert(
+ /data-message-index/.test(frontendSource) && /requestOutlineMessageTarget/.test(frontendSource),
+ 'Locator entries without a rendered DOM target should retain their message index for navigation');
assert(styleSource.includes('.history-load-more-button'), 'History load-more control should have dedicated styling');
assert(serverSource.includes('function loadNativeSessionHistory'), 'Server should be able to recover native session history');
assert(serverSource.includes('function resolveSessionHistory'), 'Server should resolve persisted and native history sources');
@@ -4108,6 +4450,20 @@ function assertHistoryRecallContract() {
'Normal session loads should keep older history on demand instead of prefetching it all'
);
+ const historyControlStart = styleSource.indexOf('.history-load-more {');
+ const historyControlEnd = styleSource.indexOf('.history-load-more-copy', historyControlStart);
+ assert(historyControlStart >= 0 && historyControlEnd > historyControlStart,
+ 'History load-more control should have an isolated base style block');
+ const historyControlStyle = styleSource.slice(historyControlStart, historyControlEnd);
+ assert(!/\bposition\s*:\s*(?:absolute|fixed|sticky)\b/.test(historyControlStyle),
+ 'History load-more control should stay in normal document flow instead of floating');
+ assert(!/(?:^|[;\s])(top|right|bottom|left|transform)\s*:/.test(historyControlStyle),
+ 'History load-more control should not pin itself to a viewport or overlay position');
+ assert(/\.messages-wrap\s*\{[\s\S]*?display:\s*flex;[\s\S]*?flex-direction:\s*column;/.test(styleSource),
+ 'Messages wrapper should reserve a normal-flow row above the scrolling messages');
+ assert(/\.messages\s*\{[\s\S]*?flex:\s*1;[\s\S]*?min-height:\s*0;/.test(styleSource),
+ 'Messages should occupy the remaining height beneath the history control');
+
const splitStart = serverSource.indexOf('function splitHistoryMessages');
const splitEnd = serverSource.indexOf('const IS_WIN', splitStart);
assert(splitStart >= 0 && splitEnd > splitStart, 'Server should keep an extractable history splitter');
@@ -4149,6 +4505,8 @@ function assertSessionSwitchRaceContract() {
['frontend requestId behavior', assertSessionRequestIdRaceContract],
['blocking finish RAF request behavior', assertBlockingFinishRafRequestRaceContract],
['recoverCurrent history merge behavior', assertRecoverCurrentHistoryMergeContract],
+ ['partial session snapshot cache behavior', assertPartialSessionSnapshotCacheContract],
+ ['session switch cache behavior', assertSessionSwitchCacheBehaviorContract],
['server history requestId behavior', assertServerSessionHistoryRequestIdContract],
];
const failures = [];
@@ -5630,7 +5988,7 @@ function assertAdvancedSessionSearchContract() {
'Existing sidebar search clear control contract should remain unchanged');
assert(indexSource.includes('id="advanced-search-panel"') && indexSource.includes('id="advanced-search-results"'),
'Advanced search workspace should expose stable panel and result hooks');
- assert(indexSource.includes('style.css?v=20260911-file-suggestion')
+ assert(indexSource.includes('style.css?v=20260913-history-control-position')
&& indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'),
'Advanced search CSS and frontend script should share the reviewed cache-bust');
@@ -5747,7 +6105,7 @@ function assertUsageStatisticsContract() {
'Usage dashboard should be a chat-main-local workspace');
assert(indexSource.includes('class="usage-dashboard-open"') && !indexSource.includes('class="settings-btn usage-dashboard-open"'),
'Usage entry must use its own class so theme-specific settings pseudo-elements cannot leak');
- assert(indexSource.includes('style.css?v=20260911-file-suggestion')
+ assert(indexSource.includes('style.css?v=20260913-history-control-position')
&& indexSource.includes('vendor/echarts.min.js?v=5.6.0')
&& indexSource.includes('app.js?v=__CC_WEB_FRONTEND_ASSET_VERSION__'),
'Usage dashboard CSS, local ECharts runtime, and frontend script should share the current asset contract');
diff --git a/server.js b/server.js
index 59ce3e7..c519892 100644
--- a/server.js
+++ b/server.js
@@ -9172,6 +9172,7 @@ wss.on('connection', (ws, req) => {
features: {
usageStatistics: USAGE_STATISTICS_ENABLED,
taskBoard: TASK_BOARD_ENABLED,
+ clientHeartbeat: true,
},
});
sendSessionList(ws);
@@ -9188,6 +9189,12 @@ wss.on('connection', (ws, req) => {
}
switch (msg.type) {
+ case 'client_heartbeat':
+ wsSend(ws, {
+ type: 'client_heartbeat_ack',
+ requestId: String(msg.requestId || ''),
+ });
+ break;
case 'task_board_query':
case 'task_tracking_set':
case 'task_status_set':