@capekai/core 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capekai/core",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Bun-native composable agent runtime and framework for Capek.",
   "license": "MIT",
   "repository": {

package/src/compaction/task.ts

@@ -404,7 +404,9 @@ export async function processCompactionTask(
   const hasUserMessage = messagesToCompact.some(
     (m: MessageWithParts) => m.message.role === 'user',
   );
-  if (!hasUserMessage) {
+  // Mid-turn continuation adds assistant/tool progress without a new user
+  // message. The previous summary carries the original user objective.
+  if (!hasUserMessage && !previousSummaryText) {
     throw new Error('Compaction boundary must contain at least one user message');
   }
 

package/src/compaction/usage.ts

@@ -0,0 +1,25 @@
+import type { ModelMessage } from 'ai';
+
+/** Approximation for new model-facing items not covered by provider usage yet.
+ * Count serialized UTF-8 bytes, not the raw tool payload before projection. */
+export function estimateMessageTokens(messages: readonly ModelMessage[]): number {
+  return Math.ceil(new TextEncoder().encode(JSON.stringify(messages)).byteLength / 4);
+}
+
+export function estimateNextStepTokens(step: {
+  usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  response?: { messages: readonly ModelMessage[] };
+}): number {
+  const messages = step.response?.messages ?? [];
+  let lastAssistant = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') {
+      lastAssistant = i;
+      break;
+    }
+  }
+  const appended = messages.slice(lastAssistant + 1);
+  const usage = step.usage;
+  return (usage?.totalTokens ?? ((usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)))
+    + (appended.length ? estimateMessageTokens(appended) : 0);
+}

package/src/core/agent.ts

@@ -41,6 +41,9 @@ export interface ChatOptions {
   broadcastFn?: BuildToolsOptions['broadcastFn'];
   responseFormat?: ResponseFormat;
   retryAbortController?: AbortController;
+  /** The caller handles needs_compaction and resumes from persisted history. */
+  compactBetweenSteps?: boolean;
+  continueFromCompaction?: boolean;
 }
 
 async function collectInterruptedToolPartEvents(
@@ -72,7 +75,7 @@ export interface ChatResult {
   toolCalls: ToolPart[];
 }
 
-export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageEvent | { type: 'usage'; usage: UsageEventData; model: string; variant: string | null } | { type: 'needs_compaction'; sessionId: string } | ErrorEvent> {
+export async function* streamChat(options: ChatOptions): AsyncGenerator<(MessageEvent & { continuation?: boolean }) | { type: 'usage'; usage: UsageEventData; model: string; variant: string | null } | { type: 'needs_compaction'; sessionId: string; resume?: boolean } | ErrorEvent> {
   const { sessionId: _sessionId, preconfig, messages, modelId, providerId, variant, workspacePath, workspaceId, maxSteps, compactionPolicy } = options;
 
   const managesSessionLifecycle = !options.retryAbortController;
@@ -155,6 +158,10 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
   // Convert messages for ai-sdk
   const modelDef = resolvedModelId ? findModel(resolvedModelId) : undefined;
   const aiMessages = await convertToAiSdkMessages(messages, modelDef?.capabilities);
+  if (options.continueFromCompaction) {
+    // Execution instruction only: do not persist it as another user request.
+    aiMessages.push({ role: 'user', content: 'Continue the existing task from the checkpoint above. Preserve completed work and tool outcomes; do not restart or repeat completed actions. Follow the remaining steps, or report completion if nothing remains.' });
+  }
 
   // Build stream config (variants, providerOptions, structured output)
   const streamConfig = buildStreamConfig({
@@ -191,6 +198,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
   };
 
   const { experimental_onStepStart, onStepFinish } = createStepCallbacks(stepCtx);
+  let stoppedForCompaction = false;
 
   const result = streamText({
     model,
@@ -200,7 +208,19 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
     maxOutputTokens: omitMaxOutputTokens ? undefined : getMaxOutputTokens(resolvedModelId),
     providerOptions: streamConfig.providerOptions as Parameters<typeof streamText>[0]['providerOptions'],
     ...(omitTemperature ? {} : { temperature: streamConfig.temperature }),
-    stopWhen: stepCountIs(streamConfig.maxSteps),
+    stopWhen: [
+      stepCountIs(streamConfig.maxSteps),
+      ({ steps }) => {
+        const step = steps.at(-1);
+        const toolsSettled = step && step.toolCalls.length > 0
+          && step.toolCalls.every(call => step.content.some(part =>
+            (part.type === 'tool-result' || part.type === 'tool-error') && part.toolCallId === call.toolCallId));
+        stoppedForCompaction = options.compactBetweenSteps === true
+          && stepCtx.needsCompaction && Boolean(toolsSettled)
+          && steps.length < streamConfig.maxSteps;
+        return stoppedForCompaction;
+      },
+    ],
     abortSignal: abortController.signal,
     experimental_onStepStart,
     onStepFinish,
@@ -269,6 +289,12 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
       case 'tool-result':
         await handlers.handleToolResult(delta);
         break;
+      case 'tool-error':
+        await handlers.handleToolResult({
+          toolCallId: delta.toolCallId,
+          output: { error: delta.error instanceof Error ? delta.error.message : String(delta.error) },
+        });
+        break;
       case 'error': {
         const error = (delta as { type: 'error'; error: unknown }).error;
         throw error;
@@ -312,7 +338,10 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
         status: 'error',
         error: classified.message,
       };
-      yield { type: 'message.updated', message: errorMessage };
+      yield {
+        type: 'message.updated', message: errorMessage,
+        continuation: options.compactBetweenSteps === true && classified.type === 'context_overflow',
+      };
       await updateMessage(messageId, errorMessage, { syncFts: false });
       await syncMessageFts(messageId);
       yield createErrorEvent(classified);
@@ -356,7 +385,8 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
     ...(structuredOutputData ? { structuredOutput: structuredOutputData } : {}),
   };
 
-  yield { type: 'message.updated', message: finalMessage };
+  await updateMessage(messageId, finalMessage, { syncFts: false });
+  yield { type: 'message.updated', message: finalMessage, continuation: stoppedForCompaction };
 
   // Sync FTS once after all final parts and message state are persisted
   await syncMessageFts(messageId);
@@ -378,7 +408,10 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
   }
 
   if (isMainSession && stepCtx.needsCompaction) {
-    yield { type: 'needs_compaction', sessionId: _sessionId };
+    const resume = stoppedForCompaction
+      && streamCtx.toolParts.length > 0
+      && streamCtx.toolParts.every(part => part.state.status === 'completed' || part.state.status === 'error');
+    yield { type: 'needs_compaction', sessionId: _sessionId, resume };
   }
 }
 

package/src/core/chat-handler.ts

@@ -1,6 +1,7 @@
-import type { ResponseFormat } from '@capekai/types';
+import type { AssistantMessage, ResponseFormat } from '@capekai/types';
 import {
   emitRuntimeEvent,
+  emitSessionUpdated,
   generateSessionTitle,
   hasManualSessionTitle,
   isDefaultSessionTitle,
@@ -30,8 +31,6 @@ import {
 } from '../storage/runtime';
 import type { AskBroadcastFn } from '../runtime/host';
 import type { RuntimeDelivery, RuntimeEvent, RuntimeEventContext } from '../runtime/events';
-import { getCompactionService } from '../compaction/policy';
-import { executeCompaction } from '../compaction/executor';
 import { getGoalDomain } from '../goals/service';
 import { interruptManager } from './interrupt';
 import { getApiKeyForProvider } from '../configuration/runtime';
@@ -88,7 +87,6 @@ async function drainQueue<Origin>(
 interface ChatTurnResult {
   streamCompleted: boolean;
   interrupted: boolean;
-  needsAutoCompaction: boolean;
   contextOverflow: boolean;
   isFatal: boolean;
   isQueueDrainable: boolean;
@@ -112,6 +110,7 @@ async function runSingleChatTurn<Origin>(
   attachments?: Array<{ id: string; kind: string }>,
   responseFormat?: ResponseFormat,
   existingUserMessageId?: string,
+  retryAbortController?: AbortController,
 ): Promise<ChatTurnResult> {
   let userMsgId: string;
 
@@ -204,8 +203,8 @@ async function runSingleChatTurn<Origin>(
     }
   };
 
-  let pendingCompaction = false;
   let retryCancelled = false;
+  let terminalMessage: AssistantMessage | undefined;
   const effectiveProvider = isSandboxActive() ? 'sandbox' : provider;
 
   try {
@@ -221,6 +220,7 @@ async function runSingleChatTurn<Origin>(
       additionalPaths,
       broadcastFn: askBroadcastFn,
       responseFormat,
+      retryAbortController,
     })) {
       switch (event.type) {
         case 'message.created':
@@ -230,7 +230,8 @@ async function runSingleChatTurn<Origin>(
         case 'message.updated':
           updateMessage(event.message.id, event.message, { syncFts: false });
           if (event.message.role === 'assistant' && event.message.mode !== 'retry_failed') {
-            emitTerminal(event.message, sessionId);
+            terminalMessage = event.message;
+            if (!event.continuation) emitTerminal(event.message, sessionId);
           }
           deliverToSession(ctx, sessionId, { kind: 'message', action: 'updated', message: event.message });
           break;
@@ -273,10 +274,6 @@ async function runSingleChatTurn<Origin>(
           break;
         }
 
-        case 'needs_compaction':
-          pendingCompaction = true;
-          break;
-
         case 'chat.retry':
           deliverToSession(ctx, sessionId, {
             kind: 'retry',
@@ -306,7 +303,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: true,
             isQueueDrainable: false,
@@ -327,7 +323,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: false,
             isQueueDrainable: true,
@@ -348,7 +343,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: false,
             isQueueDrainable: true,
@@ -368,7 +362,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: true,
             isQueueDrainable: false,
@@ -386,7 +379,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: true,
             isQueueDrainable: false,
@@ -395,10 +387,13 @@ async function runSingleChatTurn<Origin>(
           };
 
         case 'error.context_overflow': {
+          deliverToOrigin(ctx, origin, {
+            kind: 'failure', category: 'generic', code: 'context_overflow',
+            message: event.message, sessionId,
+          });
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: true,
             isFatal: false,
             isQueueDrainable: false,
@@ -417,7 +412,6 @@ async function runSingleChatTurn<Origin>(
           return {
             streamCompleted: false,
             interrupted: false,
-            needsAutoCompaction: false,
             contextOverflow: false,
             isFatal: true,
             isQueueDrainable: false,
@@ -437,8 +431,7 @@ async function runSingleChatTurn<Origin>(
 
     return {
       streamCompleted: !retryCancelled,
-      interrupted: wasInterrupted || retryCancelled,
-      needsAutoCompaction: pendingCompaction,
+      interrupted: terminalMessage?.status === 'interrupted' || wasInterrupted || retryCancelled,
       contextOverflow: false,
       isFatal: false,
       isQueueDrainable: false,
@@ -450,7 +443,6 @@ async function runSingleChatTurn<Origin>(
     return {
       streamCompleted: false,
       interrupted: false,
-      needsAutoCompaction: false,
       contextOverflow: false,
       isFatal: true,
       isQueueDrainable: false,
@@ -592,14 +584,12 @@ export async function handleChat<Origin>(
   const responseFormat = responseFormatRecord ?? undefined;
 
   if (goalCondition) {
-    const goalAbortController = new AbortController();
-    const checkInterval = setInterval(() => {
-      if (interruptManager.isSessionInterrupted(sessionId) && !goalAbortController.signal.aborted) {
-        goalAbortController.abort(new Error('Goal loop cancelled by user'));
-      }
-    }, 200);
+    const goalAbortController = interruptManager.registerSession(sessionId, session.parentId ?? undefined);
 
+    let firstGoalTurn = true;
     try {
+      const running = await updateSession(sessionId, { runningAt: new Date().toISOString() });
+      if (running) emitSessionUpdated(running);
       await getGoalDomain().runGoalLoop({
         sessionId,
         condition: goalCondition,
@@ -610,8 +600,10 @@ export async function handleChat<Origin>(
         runTurn: async (turnContent: string) => {
           const result = await runSingleChatTurn(
             ctx, origin, sessionId, turnContent, preconfig, modelId, provider,
-            workspacePath, additionalPaths, session, undefined, responseFormat,
+            workspacePath, additionalPaths, session, firstGoalTurn ? attachments : undefined, responseFormat,
+            undefined, goalAbortController,
           );
+          firstGoalTurn = false;
           return {
             streamCompleted: result.streamCompleted,
             interrupted: result.interrupted,
@@ -619,14 +611,15 @@ export async function handleChat<Origin>(
         },
       });
     } finally {
-      clearInterval(checkInterval);
+      interruptManager.unregisterSession(sessionId);
+      const stopped = await updateSession(sessionId, { runningAt: null });
+      if (stopped) emitSessionUpdated(stopped);
     }
     return;
   }
 
   let currentContent: string = content;
   let currentAttachments: Array<{ id: string; kind: string }> | undefined = attachments;
-  let overflowRetryDepth = 0;
 
   while (true) {
     const result = await runSingleChatTurn(
@@ -644,77 +637,34 @@ export async function handleChat<Origin>(
       responseFormat,
     );
 
-    if (result.contextOverflow) {
-      if (overflowRetryDepth >= 1) {
-        deliverToOrigin(ctx, origin, {
-          kind: 'failure',
-          category: 'generic',
-          code: 'context_overflow',
-          message: result.errorMessage ?? 'Context overflow',
-        });
-        return;
-      }
+    if (result.contextOverflow) return;
 
-      const currentSession = await getSession(sessionId);
-      const isMainSession = currentSession && !currentSession.parentId;
-
-      if (isMainSession && !getCompactionService().shouldSkipCompaction(sessionId)) {
-        const replayText = await getCompactionService().buildReplayText(sessionId);
-        const execResult = await executeCompaction(sessionId, 'overflow');
-
-        if (execResult.ok) {
-          getCompactionService().clearCompactionFailure(sessionId);
-          overflowRetryDepth++;
-          currentContent = replayText ?? 'Continue from where we left off, using the compacted context.';
-          continue;
-        } else if (!execResult.skipped) {
-          getCompactionService().recordCompactionFailure(sessionId);
-          console.warn(`[handleChat] Overflow compaction failed for session ${sessionId}: ${execResult.error}`);
-        }
-      }
 
-      deliverToOrigin(ctx, origin, {
-        kind: 'failure',
-        category: 'generic',
-        code: 'context_overflow',
-        message: result.errorMessage ?? 'Context overflow',
-      });
+    if (result.isFatal) {
       return;
     }
 
-    if (result.isFatal || result.interrupted) {
-      return;
-    }
-
-    if (result.isQueueDrainable) {
+    if (result.interrupted) {
+      // The old turn has finished cleanup; queued input starts a fresh turn.
       const next = await drainQueue(ctx, sessionId);
-      if (next) {
-        currentContent = next.content;
-        currentAttachments = next.attachments;
-        continue;
+      if (!next) {
+        return;
       }
+      currentContent = next.content;
+      currentAttachments = next.attachments;
+      continue;
     }
 
-    if (result.streamCompleted && result.needsAutoCompaction) {
-      const currentSession = await getSession(sessionId);
-      if (currentSession && !currentSession.parentId && !getCompactionService().shouldSkipCompaction(sessionId)) {
-        const execResult = await executeCompaction(sessionId, 'auto');
-        if (execResult.ok) {
-          getCompactionService().clearCompactionFailure(sessionId);
-        } else if (!execResult.skipped) {
-          getCompactionService().recordCompactionFailure(sessionId);
-          console.warn(`[handleChat] Auto-compaction failed for session ${sessionId}: ${execResult.error}`);
-        }
-      }
+    if (result.isQueueDrainable) {
       const next = await drainQueue(ctx, sessionId);
       if (next) {
         currentContent = next.content;
         currentAttachments = next.attachments;
         continue;
       }
-      return;
     }
 
+
     if (result.streamCompleted) {
       const next = await drainQueue(ctx, sessionId);
       if (next) {

package/src/core/step-handlers.ts

@@ -1,4 +1,6 @@
+import type { ModelMessage } from 'ai';
 import type { MessageEvent, StepPart } from '@capekai/types';
+import { estimateNextStepTokens } from '../compaction/usage';
 import { createPart, updatePart } from '../storage/runtime';
 import { createStepPart } from './part-utils';
 import { randomUUID } from 'crypto';
@@ -63,7 +65,7 @@ export function createStepCallbacks(ctx: StepCallbacksContext) {
       }
       await createPart(startedStepPart, ctx.sessionId);
     },
-    onStepFinish: async (stepFinishEvent: { stepNumber: number; finishReason: string | null; usage?: StepUsage; totalUsage?: StepUsage }) => {
+    onStepFinish: async (stepFinishEvent: { stepNumber: number; finishReason: string | null; usage?: StepUsage; totalUsage?: StepUsage; response?: { messages: ModelMessage[] } }) => {
       const stepNumber = stepFinishEvent.stepNumber + 1;
 
       const stepUsage = stepFinishEvent.usage;
@@ -74,8 +76,7 @@ export function createStepCallbacks(ctx: StepCallbacksContext) {
       const stepNoCacheTokens = stepUsage?.inputTokenDetails?.noCacheTokens ?? 0;
 
       if (ctx.isMainSession && ctx.contextWindow) {
-        const latestStepInputTokens = stepUsage?.inputTokens ?? 0;
-        if (latestStepInputTokens >= ctx.autoThreshold) {
+        if (estimateNextStepTokens(stepFinishEvent) >= ctx.autoThreshold) {
           ctx.needsCompaction = true;
         }
       }

package/src/goals/evaluator.ts

@@ -15,16 +15,25 @@ import { runOrchestratorSession } from '../workflow/orchestrator-session';
  */
 
 const MAX_TRANSCRIPT_MESSAGES = 20;
-const MAX_TOOL_OUTPUT_CHARS = 500;
+const MAX_TOOL_OUTPUT_CHARS = 1000;
+const MAX_RECENT_CHARS = 24000;
+const MAX_CHECKPOINT_CHARS = 8000;
+
+function excerpt(text: string, limit: number): string {
+  if (text.length <= limit) return text;
+  const marker = '\n[...truncated...]\n';
+  const half = Math.floor((limit - marker.length) / 2);
+  return text.slice(0, half) + marker + text.slice(-(limit - marker.length - half));
+}
 
 function summarizeToolState(toolPart: ToolPart): string {
   const state = toolPart.state;
   if (state.status === 'completed') {
-    if (typeof state.output === 'string') return state.output.slice(0, MAX_TOOL_OUTPUT_CHARS);
-    if (state.output && typeof state.output === 'object') return JSON.stringify(state.output).slice(0, MAX_TOOL_OUTPUT_CHARS);
+    if (typeof state.output === 'string') return excerpt(state.output, MAX_TOOL_OUTPUT_CHARS);
+    if (state.output && typeof state.output === 'object') return excerpt(JSON.stringify(state.output), MAX_TOOL_OUTPUT_CHARS);
     return '(completed)';
   }
-  if (state.status === 'error') return `ERROR: ${state.error ?? 'unknown'}`;
+  if (state.status === 'error') return excerpt(`ERROR: ${state.error ?? 'unknown'}`, MAX_TOOL_OUTPUT_CHARS);
   return `(${state.status})`;
 }
 
@@ -33,23 +42,43 @@ async function buildTranscriptSummary(
   sessionId: string,
 ): Promise<string> {
   const messages = await listTranscript(sessionId);
-  return messages.slice(-MAX_TRANSCRIPT_MESSAGES).map((entry) => {
-    if (entry.message.role === 'user') {
-      const text = entry.parts
-        .filter((part): part is TextPart => part.type === 'text')
-        .map((part) => part.text || '')
-        .join('');
-      return text ? `[USER]: ${text}` : '';
-    }
-    if (entry.message.role === 'assistant') {
-      return entry.parts.map((part) => {
-        if (part.type === 'text' && part.text) return `[ASSISTANT]: ${part.text}`;
-        if (part.type === 'tool') return `[TOOL: ${part.name}]: ${summarizeToolState(part)}`;
-        return '';
-      }).filter(Boolean).join('\n');
-    }
-    return '';
-  }).filter(Boolean).join('\n\n');
+  const checkpoint = [...messages].reverse().find(entry => entry.message.role === 'assistant'
+    && entry.message.summary === true && entry.message.mode === 'compaction');
+  const checkpointText = checkpoint?.parts
+    .filter((part): part is TextPart => part.type === 'text')
+    .map(part => part.text || '').join('\n');
+  // Keep raw recent tool evidence even when it predates the checkpoint.
+  // Summaries are claims, not independent proof of goal completion.
+  const recent = messages.filter(entry => entry.message.role !== 'assistant'
+    || (!entry.message.summary && entry.message.mode !== 'retry_failed' && entry.message.mode !== 'compact_failed'))
+    .slice(-MAX_TRANSCRIPT_MESSAGES).map(entry => {
+      if (entry.message.role === 'user') {
+        const text = entry.parts.filter((part): part is TextPart => part.type === 'text')
+          .map(part => part.text || '').join('');
+        return text ? `[USER]: ${excerpt(text, 2000)}` : '';
+      }
+      if (entry.message.role === 'assistant') {
+        return entry.parts.map(part => {
+          if (part.type === 'text' && part.text) return `[ASSISTANT]: ${excerpt(part.text, 2000)}`;
+          if (part.type === 'tool') return `[TOOL: ${part.name}]: ${summarizeToolState(part)}`;
+          return '';
+        }).filter(Boolean).join('\n');
+      }
+      return '';
+    }).filter(Boolean);
+  // Prefer newest evidence within the budget, independently of checkpoint size.
+  let remaining = MAX_RECENT_CHARS;
+  const selected: string[] = [];
+  for (const entry of recent.reverse()) {
+    if (remaining <= 100) break;
+    const bounded = excerpt(entry, Math.min(remaining - 2, 4000));
+    selected.unshift(bounded);
+    remaining -= bounded.length + 2;
+  }
+  return [
+    checkpointText ? `[COMPACTION CHECKPOINT, summary claims only, not direct evidence]:\n${excerpt(checkpointText, MAX_CHECKPOINT_CHARS)}` : '',
+    ...selected,
+  ].filter(Boolean).join('\n\n');
 }
 
 /** Structural copy of the shared orchestrator-session contract result. The

package/src/goals/loop.ts

@@ -154,6 +154,10 @@ export async function runGoalLoopWithDeps(
       console.error('[goal:loop] Evaluator failed', { turn, error: err instanceof Error ? err.message : String(err) });
       evaluation = { goalMet: false, reason: 'Evaluator call failed — continuing work' };
     }
+    if (abortSignal?.aborted) {
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'cancelled', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
     if (evaluation.goalMet) {
       console.log('[goal:loop] GOAL MET!', { turn, reason: evaluation.reason });
       await updateGoalStateWithDeps(deps, sessionId, { status: 'met', completedAt: Date.now() }, broadcastSessUpdated);

package/src/retry/stream-chat.ts

@@ -12,6 +12,9 @@
  */
 
 import type { ChatOptions } from '../core/agent';
+import { getLLMMaxSteps } from '../configuration/runtime';
+import { executeCompaction } from '../compaction/executor';
+import { getCompactionService } from '../compaction/policy';
 import type { UsageEventData } from '../core/step-handlers';
 import type {
   AssistantMessage, AuthErrorMessage, ChatRetryMessage, ContextOverflowErrorMessage, ErrorMessage, InvalidRequestErrorMessage, MessageEvent, RateLimitErrorMessage, ServerErrorMessage, TimeoutErrorMessage, ToolPart } from '@capekai/types';
@@ -25,6 +28,7 @@ import {
 } from '../utils/errors';
 import { emitSessionUpdated } from '../runtime/host-dependencies';
 import {
+  buildEffectiveContextHistory,
   getPartsByMessage,
   getSession,
   syncMessageFts,
@@ -41,9 +45,9 @@ import {
 } from './policy';
 
 export type StreamChatEvent =
-  | MessageEvent
+  | (MessageEvent & { continuation?: boolean })
   | { type: 'usage'; usage: UsageEventData; model: string; variant: string | null }
-  | { type: 'needs_compaction'; sessionId: string }
+  | { type: 'needs_compaction'; sessionId: string; resume?: boolean }
   | ChatRetryMessage
   | RateLimitErrorMessage
   | ServerErrorMessage
@@ -81,8 +85,8 @@ async function finalizeFailedAttempt(
     completedAt: Date.now(),
     ...(retryFailed ? { mode: 'retry_failed' as const } : {}),
   };
-  updateMessage(message.id, errorMessage, { syncFts: false });
-  syncMessageFts(message.id);
+  await updateMessage(message.id, errorMessage, { syncFts: false });
+  await syncMessageFts(message.id);
   events.push({ type: 'message.updated', message: errorMessage });
   return events;
 }
@@ -130,6 +134,7 @@ export async function* streamChatWithRetry(
   options: ChatOptions,
   streamChatFn?: StreamChatFn,
   policyOptions: StreamRetryPolicy = {},
+  compact: typeof executeCompaction = executeCompaction,
 ): AsyncGenerator<StreamChatEvent> {
   const policy = getRetryPolicy();
   const maxRetries = policyOptions.maxRetries ?? policy.defaults.maxRetries;
@@ -138,10 +143,12 @@ export async function* streamChatWithRetry(
   const jitterRatio = policyOptions.jitterRatio ?? policy.defaults.jitterRatio;
   const circuitKey = policy.circuitKey(options.providerId, options.modelId);
   const session = await getSession(options.sessionId);
-  const abortController = interruptManager.registerSession(options.sessionId, session?.parentId ?? undefined);
+  const managesSessionLifecycle = !options.retryAbortController;
+  const abortController = options.retryAbortController
+    ?? interruptManager.registerSession(options.sessionId, session?.parentId ?? undefined);
   const isMainSession = session && !session.parentId;
 
-  if (isMainSession) {
+  if (isMainSession && managesSessionLifecycle) {
     const updatedSession = await updateSession(options.sessionId, { runningAt: new Date().toISOString() });
     if (updatedSession) {
       emitSessionUpdated(updatedSession);
@@ -171,13 +178,35 @@ export async function* streamChatWithRetry(
     }
 
     let retries = 0;
+    let overflowRetried = false;
+    let remainingSteps = options.maxSteps ?? getLLMMaxSteps();
+    let messages = options.messages;
+    let continueFromCompaction = false;
     while (retries <= maxRetries) {
       let lastAssistantMessage: AssistantMessage | null = null;
       let attemptHadToolActivity = false;
+      let maintenanceStarted = false;
+      let pendingCompaction: Extract<StreamChatEvent, { type: 'needs_compaction' }> | undefined;
+      let overflow: ContextOverflowErrorMessage | undefined;
+      const finishedSteps = new Set<string>();
 
       try {
         const stream = streamChatFn ?? (await import('../core/agent')).streamChat;
-        for await (const event of stream({ ...options, retryAbortController: abortController })) {
+        for await (const event of stream({
+          ...options, messages, maxSteps: remainingSteps,
+          compactBetweenSteps: true, continueFromCompaction, retryAbortController: abortController,
+        })) {
+          if (event.type === 'needs_compaction') {
+            pendingCompaction = event;
+            continue;
+          }
+          if (event.type === 'error.context_overflow') {
+            overflow = event;
+            continue;
+          }
+          if (event.type === 'part.updated' && event.part.type === 'step' && event.part.status === 'finished') {
+            finishedSteps.add(event.part.id);
+          }
           if (event.type === 'message.created' || event.type === 'message.updated') {
             if (event.message.role === 'assistant') {
               lastAssistantMessage = event.message as AssistantMessage;
@@ -191,6 +220,64 @@ export async function* streamChatWithRetry(
           yield event;
         }
         policy.resetCircuit(circuitKey);
+        if (abortController.signal.aborted) return;
+        if (overflow || pendingCompaction) {
+          maintenanceStarted = true;
+          // An uncertain tool outcome is not a safe checkpoint to resume from.
+          const parts = lastAssistantMessage ? await getPartsByMessage(lastAssistantMessage.id) : [];
+          if (parts.some(part => part.type === 'tool' && (part.state.status === 'pending' || part.state.status === 'running'))) {
+            const message = 'Cannot compact and continue while tool outcomes are unresolved.';
+            yield* await finalizeFailedAttempt(lastAssistantMessage, { message }, false);
+            yield overflow ?? { type: 'error', code: 'compaction_unsafe', message };
+            return;
+          }
+          const service = getCompactionService();
+          const mustResume = Boolean(overflow || pendingCompaction?.resume);
+          const reason = overflow ? 'overflow' : 'auto';
+          if (!isMainSession || service.shouldSkipCompaction(options.sessionId) || (overflow && overflowRetried)) {
+            if (mustResume) {
+              const message = overflow?.message ?? 'Cannot continue while context compaction is unavailable.';
+              yield* await finalizeFailedAttempt(lastAssistantMessage, { message }, false);
+              yield overflow ?? { type: 'error', code: 'compaction_unavailable', message };
+            }
+            return;
+          }
+          const result = await compact(options.sessionId, reason, undefined, undefined, abortController.signal);
+          if (abortController.signal.aborted) {
+            if (lastAssistantMessage) {
+              const interrupted: AssistantMessage = { ...lastAssistantMessage, status: 'interrupted', error: 'Interrupted by user' };
+              await updateMessage(interrupted.id, interrupted, { syncFts: false });
+              await syncMessageFts(interrupted.id);
+              yield { type: 'message.updated', message: interrupted };
+            }
+            return;
+          }
+          if (!result.ok) {
+            if (!result.skipped) service.recordCompactionFailure(options.sessionId);
+            if (mustResume) {
+              yield* await finalizeFailedAttempt(lastAssistantMessage, { message: result.error }, false);
+              yield overflow ?? { type: 'error', code: 'compaction_failed', message: result.error };
+            }
+            return;
+          }
+          service.clearCompactionFailure(options.sessionId);
+          if (!mustResume) return;
+          // Compaction is continuation, not a retry: completed tools are in the
+          // checkpoint and the original user input is never appended again.
+          remainingSteps -= overflow ? finishedSteps.size : Math.max(1, finishedSteps.size);
+          if (remainingSteps <= 0) {
+            if (overflow) {
+              yield* await finalizeFailedAttempt(lastAssistantMessage, { message: overflow.message }, false);
+              yield overflow;
+            }
+            return;
+          }
+          overflowRetried ||= Boolean(overflow);
+          messages = (await buildEffectiveContextHistory(options.sessionId)).messages;
+          continueFromCompaction = true;
+          retries = 0;
+          continue;
+        }
         return;
       } catch (err) {
         const classifiedError = policy.classify(err);
@@ -208,6 +295,7 @@ export async function* streamChatWithRetry(
         // or after the run was aborted.
         const canRetry = policyCanRetry
           && !attemptHadToolActivity
+          && !maintenanceStarted
           && !abortController.signal.aborted;
         const circuitOpened = classifiedError.retryable
           && !canRetry
@@ -300,9 +388,9 @@ export async function* streamChatWithRetry(
       }
     }
   } finally {
-    interruptManager.unregisterSession(options.sessionId);
+    if (managesSessionLifecycle) interruptManager.unregisterSession(options.sessionId);
     await rejectPendingAsksBySession(options.sessionId);
-    if (isMainSession) {
+    if (isMainSession && managesSessionLifecycle) {
       const updatedSession = await updateSession(options.sessionId, { runningAt: null });
       if (updatedSession) {
         emitSessionUpdated(updatedSession);