@wangzhizhi/remi 0.1.225 → 0.1.244

package/node_modules/@remi/core/dist/index.js

@@ -1,19 +1,23 @@
 import { loadRemiConfig, normalizePermissionProfile, resolveToolPermissionMode, } from '@remi/config';
 import { buildBaseSystemPrompt, buildCurrentTurnSystemPrompt, defaultResponseStyleId, resolveResponseStyle, } from './responseStyles.js';
 import { buildProviderContext } from './contextBuilder.js';
+import { buildCacheDiagnostic, latestCacheDiagnostic } from './cacheDiagnostics.js';
 import { buildDirectoryOverviewPrelude } from './directoryOverview.js';
 import { buildProjectInstructionsContext } from './projectInstructions.js';
 import { readPromptFile } from './promptFiles.js';
+import { stableJson } from './stableHash.js';
 import { executeConfiguredHooks, hasHookForEvent, } from '@remi/hooks';
 import { emptyMemoryRecall, recallRelevantMemories, recordMemoryUse } from '@remi/memory';
-import { compactSession, estimateSessionTokens, estimateTextTokens, eventsAfterLatestCompact, latestCompactSummary, maybeUpdateSessionMemory, readSessionMemory } from '@remi/compact';
+import { compactSession, estimateSessionTokens, estimateTextTokens, eventsAfterLatestCompact, latestCompactSummary, maybeUpdateSessionMemory, readSessionMemory, } from '@remi/compact';
 import { formatSkillIndexContext, loadSkillContent, loadSkillIndex } from '@remi/skills';
 export { buildBaseSystemPrompt, buildCurrentTurnSystemPrompt, buildResponseLanguageSystemPrompt, buildResponseStyleSystemPrompt, defaultResponseStyleId, isResponseStyleId, normalizeResponseStyleId, resolveResponseStyle, responseStylePresets, } from './responseStyles.js';
 export { buildProviderContext, } from './contextBuilder.js';
 export { buildProjectInstructionsContext } from './projectInstructions.js';
 export { promptFileCandidates, readPromptFile } from './promptFiles.js';
+export { buildCacheDiagnosticReport, formatCacheDiagnosticStatus, } from './cacheDiagnostics.js';
+export { buildCacheShapeBenchmark, buildRemiCacheShapeBenchmarkFixture, buildRemiCacheShapeBenchmarkRequest, } from './cacheBenchmark.js';
 import { createModelRouter, createProviderClient, createTokenEstimatorRegistry, } from '@remi/llm';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { createSessionStore, readSessionEvents, writeToolResultArtifact } from '@remi/sessions';
 import { createMcpAwareToolRegistry, createMcpRuntime } from '@remi/mcp';
@@ -162,6 +166,11 @@ const maxAutoCompactFailures = 3;
 const maxFilesystemContextEvents = 120;
 const maxFilesystemContextRoots = 8;
 const maxFilesystemContextPaths = 12;
+const maxRecentContinuationEvents = 160;
+const maxRecentLoadedSkills = 3;
+const maxRecentToolFacts = 8;
+const maxRecentFileExcerpts = 2;
+const maxRecentFileExcerptChars = 2_000;
 const maxFailedToolContextTurns = 3;
 const maxFailedToolContextTextChars = 240;
 const toolResultArtifactThresholdBytes = 16 * 1024;
@@ -191,7 +200,7 @@ export function createAgentReadOnlyToolExecutor() {
 export function createAgentLocalToolExecutor() {
     return createRemiLocalToolExecutor(createAgentToolRegistry());
 }
-function createContextBudget(model, config, runtimeConfig) {
+export function createContextBudget(model, config, runtimeConfig) {
     const contextWindowTokens = Math.max(1, model.contextWindow);
     const configuredOutputReserve = config.maxOutputReserveTokens ?? runtimeConfig?.maxOutputReserveTokens;
     const modelOutputReserve = Math.min(model.maxOutputTokens ?? defaultMaxOutputReserveTokens, defaultMaxOutputReserveTokens);
@@ -251,18 +260,17 @@ function shouldAutoCompactSession(options) {
         maxSummaryChars: tokenBudgetToChars(options.budget.tokenBudgets.compact ?? 6_000),
     };
 }
-function performAutoCompactSession(options) {
+async function performAutoCompactSession(options) {
     try {
-        try {
-            maybeUpdateSessionMemory(options.cwd, options.sessionId, { force: true, maxSummaryChars: Math.min(options.maxSummaryChars, 8_000) });
-        }
-        catch {
-            // Auto compact can still proceed from transcript if session memory update fails.
-        }
-        const result = compactSession(options.cwd, options.sessionId, {
+        const result = await compactCurrentSession({
+            cwd: options.cwd,
+            sessionId: options.sessionId,
             maxSummaryChars: options.maxSummaryChars,
             trigger: 'auto',
-            strategy: 'deterministic',
+            strategy: options.strategy,
+            env: options.env,
+            ...(options.provider ? { provider: options.provider } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
         });
         autoCompactFailuresBySession.delete(options.failureKey);
         return {
@@ -271,7 +279,7 @@ function performAutoCompactSession(options) {
             estimatedTokens: result.estimatedTokens,
             sourceEventCount: result.sourceEventCount,
             trigger: 'auto',
-            strategy: 'deterministic',
+            strategy: result.strategy,
             events: readSessionEvents(options.cwd, options.sessionId),
         };
     }
@@ -280,6 +288,161 @@ function performAutoCompactSession(options) {
         return { compacted: false };
     }
 }
+export async function compactCurrentSession(options) {
+    const env = options.env ?? process.env;
+    const loaded = loadRemiConfig({ cwd: options.cwd });
+    const strategy = options.strategy ?? loaded.config.agent?.compactStrategy ?? 'deterministic';
+    const trigger = options.trigger ?? 'manual';
+    const maxSummaryChars = options.maxSummaryChars;
+    if (strategy === 'model') {
+        const summary = await tryBuildModelCompactSummary({
+            cwd: options.cwd,
+            sessionId: options.sessionId,
+            env,
+            loadedConfig: loaded.config,
+            ...(options.provider ? { provider: options.provider } : {}),
+            ...(options.modelOverrides ? { modelOverrides: options.modelOverrides } : {}),
+            ...(options.responseStyle ? { responseStyle: options.responseStyle } : {}),
+            ...(maxSummaryChars !== undefined ? { maxSummaryChars } : {}),
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (summary && summary.trim().length > 0) {
+            return compactSession(options.cwd, options.sessionId, {
+                trigger,
+                strategy: 'model',
+                updateSessionMemory: false,
+                ...(maxSummaryChars !== undefined ? { maxSummaryChars } : {}),
+                summaryOverride: summary,
+            });
+        }
+    }
+    return compactSession(options.cwd, options.sessionId, {
+        trigger,
+        strategy: 'deterministic',
+        updateSessionMemory: false,
+        ...(maxSummaryChars !== undefined ? { maxSummaryChars } : {}),
+    });
+}
+async function tryBuildModelCompactSummary(options) {
+    try {
+        const router = createModelRouter(options.loadedConfig, options.env);
+        for (const [role, modelAlias] of Object.entries(options.modelOverrides ?? {})) {
+            if (modelAlias) {
+                router.switchRoleModel(role, modelAlias);
+            }
+        }
+        const resolved = router.resolve('compact');
+        if (resolved.apiKeyStatus === 'missing') {
+            return undefined;
+        }
+        const providerConfig = options.loadedConfig.providers?.[resolved.providerAlias];
+        if (!providerConfig && !options.provider) {
+            return undefined;
+        }
+        const provider = options.provider ?? createProviderClient(providerConfig, options.env);
+        const events = readSessionEvents(options.cwd, options.sessionId);
+        const activeEvents = eventsAfterLatestCompact(events);
+        if (activeEvents.length === 0) {
+            return undefined;
+        }
+        const sessionMemorySummary = readSessionMemory(options.cwd, options.sessionId)?.content;
+        const budget = createContextBudget(resolved, {}, options.loadedConfig.agent);
+        const sourceBudgetTokens = Math.max(2_048, Math.floor(budget.effectiveInputBudgetTokens * 0.65));
+        const sourceText = buildModelCompactSource({
+            events,
+            maxChars: tokenBudgetToChars(sourceBudgetTokens),
+            ...(sessionMemorySummary ? { sessionMemorySummary } : {}),
+        });
+        const responseStyle = resolveResponseStyle(options.responseStyle ?? options.loadedConfig.responseStyle ?? defaultResponseStyleId);
+        const instruction = readPromptFile('compact-summary.md');
+        const messages = [
+            { role: 'system', content: buildBaseSystemPrompt(responseStyle.id, undefined) },
+            { role: 'user', content: sourceText },
+            { role: 'user', content: instruction },
+        ];
+        let summary = '';
+        for await (const chunk of provider.streamChat(messages, resolved, {
+            ...(options.signal ? { signal: options.signal } : {}),
+            timeoutMs: options.timeoutMs ?? defaultTimeoutMs,
+        })) {
+            if (typeof chunk === 'string') {
+                summary += chunk;
+            }
+            else if (chunk?.type === 'tool_call' || chunk?.type === 'tool_call_delta' || chunk?.type === 'tool_calls_done') {
+                return undefined;
+            }
+        }
+        return sanitizeModelCompactSummary(summary, options.maxSummaryChars);
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildModelCompactSource(options) {
+    const priorSummary = latestCompactSummary(options.events);
+    const activeEvents = eventsAfterLatestCompact(options.events);
+    const sections = [
+        '# Session Segment To Compact',
+        '',
+        ...(priorSummary ? ['## Prior Compact Summary', '', truncateText(priorSummary, 2_000), ''] : []),
+        ...(options.sessionMemorySummary ? ['## Session Memory', '', truncateText(options.sessionMemorySummary, 2_000), ''] : []),
+        '## Active Transcript Since Latest Compact',
+        '',
+        ...activeEvents.map(formatCompactSourceEvent),
+    ];
+    return truncateText(sections.join('\n'), options.maxChars);
+}
+function formatCompactSourceEvent(event) {
+    if (event.type === 'user') {
+        return `- user: ${compactText(event.content, 600)}`;
+    }
+    if (event.type === 'assistant') {
+        return `- assistant: ${compactText(event.content, 600)}`;
+    }
+    if (event.type === 'system') {
+        return `- system ${event.level}: ${compactText(event.content, 300)}`;
+    }
+    if (event.type === 'skill_use') {
+        return `- skill loaded ${event.name}: ${event.filePath}`;
+    }
+    if (event.type === 'pending_action') {
+        const command = event.completionCommand ?? event.command ?? 'external action';
+        return `- pending action from ${event.sourceToolName}: ${compactText(command, 300)}`;
+    }
+    if (event.type === 'tool_call') {
+        return `- tool call ${event.toolName}: ${compactText(JSON.stringify(event.input), 300)}`;
+    }
+    if (event.type === 'tool_result') {
+        const status = event.ok ? 'ok' : 'failed';
+        const artifact = event.artifact ? ` artifact=${event.artifact.path} (${event.artifact.bytes} bytes)` : '';
+        return `- tool result ${event.toolName} ${status}: ${compactText(event.summary, 500)}${artifact}`;
+    }
+    if (event.type === 'compact') {
+        return `- compact boundary ${event.trigger ?? 'manual'} ${event.strategy ?? 'deterministic'}: ${compactText(event.summary, 400)}`;
+    }
+    if (event.type === 'cache_diagnostic') {
+        return `- cache diagnostic: hit=${Math.round(event.usage.cacheHitRate * 100)}% miss=${event.inference.missReason} changed=${event.inference.changedLayers.join(',') || 'none'}`;
+    }
+    return '- unknown event';
+}
+function sanitizeModelCompactSummary(summary, maxSummaryChars) {
+    const trimmed = summary.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    const sanitized = trimmed
+        .replace(/```(?:SEARCH\/REPLACE|search\/replace|diff)[\s\S]*?```/g, '[omitted edit block]')
+        .replace(/<tool_call[\s\S]*?<\/tool_call>/g, '[omitted tool call]')
+        .trim();
+    return truncateText(sanitized, maxSummaryChars ?? 6_000);
+}
+function truncateText(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 24)).trimEnd()}\n... truncated ...`;
+}
 function isAutoCompactEnabled(config, runtimeConfig, env) {
     if (env['REMI_DISABLE_AUTO_COMPACT'] === '1' || env['DISABLE_COMPACT'] === '1') {
         return false;
@@ -424,6 +587,7 @@ export async function* runChatTurn(input, config = {}) {
         yield { type: 'error', sessionId: sessionStore.sessionId, message };
         return;
     }
+    const provider = config.provider ?? createProviderClient(providerConfig, env);
     const contextBudget = createContextBudget(resolved, config, loaded.config.agent);
     const tokenEstimatorResolution = tokenEstimatorRegistry.resolve(resolved);
     let sessionEvents = config.sessionStore ? [] : readSessionEvents(cwd, sessionStore.sessionId);
@@ -445,20 +609,25 @@ export async function* runChatTurn(input, config = {}) {
                 sessionId: sessionStore.sessionId,
                 failureKey: autoCompactDecision.failureKey,
                 maxSummaryChars: autoCompactDecision.maxSummaryChars,
+                strategy: config.compactStrategy ?? loaded.config.agent?.compactStrategy ?? 'deterministic',
+                env,
+                provider: config.compactProvider ?? provider,
+                ...(config.signal ? { signal: config.signal } : {}),
             });
-            if (autoCompact.compacted) {
+            const autoCompactResult = await autoCompact;
+            if (autoCompactResult.compacted) {
                 yield {
                     type: 'compact',
-                    summary: autoCompact.summary,
-                    estimatedTokens: autoCompact.estimatedTokens,
-                    sourceEventCount: autoCompact.sourceEventCount,
+                    summary: autoCompactResult.summary,
+                    estimatedTokens: autoCompactResult.estimatedTokens,
+                    sourceEventCount: autoCompactResult.sourceEventCount,
                     automatic: true,
-                    trigger: autoCompact.trigger,
-                    strategy: autoCompact.strategy,
+                    trigger: autoCompactResult.trigger,
+                    strategy: autoCompactResult.strategy,
                 };
-                sessionEvents = autoCompact.events;
+                sessionEvents = autoCompactResult.events;
             }
-            yield { type: 'compact_end', automatic: true, trigger: 'auto', ok: autoCompact.compacted };
+            yield { type: 'compact_end', automatic: true, trigger: 'auto', ok: autoCompactResult.compacted };
         }
     }
     const standaloneCurrentTask = isStandaloneRepositoryInitPrompt(input);
@@ -518,11 +687,13 @@ export async function* runChatTurn(input, config = {}) {
         : undefined;
     const recentFilesystemContext = toolDefinitions.length > 0 && !standaloneCurrentTask ? buildRecentFilesystemContext(sessionEventsForContext, cwd, env) : undefined;
     const recentFailedToolContext = toolDefinitions.length > 0 && !standaloneCurrentTask ? buildRecentFailedToolContext(sessionEventsForContext) : undefined;
+    const recentContinuationContext = toolDefinitions.length > 0 && !standaloneCurrentTask ? buildRecentContinuationContext(sessionEventsForContext, cwd, env) : undefined;
     const projectInstructionsContext = buildProjectInstructionsContext(cwd);
+    const recentLoadedSkills = toolDefinitions.length > 0 && !standaloneCurrentTask ? loadRecentSessionSkills(sessionEventsForContext, skillLoadOptions) : [];
     const loadedSkills = [];
-    const loadedSkillNames = new Set();
-    const skillContext = formatSkillIndexContext(skillIndex);
-    const projectInstructions = mergeProjectInstructionSections(projectInstructionsContext.content, recentFilesystemContext, recentFailedToolContext, skillContext);
+    const loadedSkillNames = new Set(recentLoadedSkills.map(skill => normalizeSkillNameForRuntime(skill.name)));
+    const skillContext = formatSkillIndexContext(skillIndex, recentLoadedSkills);
+    const projectInstructions = mergeProjectInstructionSections(projectInstructionsContext.content, skillContext);
     const memoryRecall = config.disableMemory || !shouldOfferMemoryForInput(input)
         ? emptyMemoryRecall(input, config.maxMemoryItems ?? defaultMaxMemoryItems)
         : recallRelevantMemories(cwd, input, {
@@ -530,11 +701,13 @@ export async function* runChatTurn(input, config = {}) {
             maxBodyChars: config.maxMemoryChars ?? defaultMaxMemoryChars,
         });
     const toolUsePrompts = toolDefinitions.length > 0 ? buildToolUseSystemPrompts(cwd, env, planPromptMode(config.planMode, planFirstRequirement), responseLanguage) : undefined;
+    const runtimePrompt = mergeProjectInstructionSections(toolUsePrompts?.runtimePrompt, recentFilesystemContext, recentContinuationContext, recentFailedToolContext);
     const providerContext = buildProviderContext({
         systemPrompt: buildBaseSystemPrompt(responseStyle.id, responseLanguage),
-        ...(toolUsePrompts ? { toolPrompt: toolUsePrompts.toolPrompt, runtimePrompt: toolUsePrompts.runtimePrompt } : {}),
+        ...(toolUsePrompts ? { toolPrompt: toolUsePrompts.toolPrompt } : {}),
+        ...(runtimePrompt ? { runtimePrompt } : {}),
         ...(projectInstructions ? { projectInstructions } : {}),
-        projectInstructionsSource: projectInstructionSource(projectInstructionsContext, Boolean(recentFilesystemContext || recentFailedToolContext)),
+        projectInstructionsSource: projectInstructionSource(projectInstructionsContext),
         memories: memoryRecall.memories,
         ...(sessionMemorySummary ? { sessionMemorySummary } : {}),
         ...(compactSummary ? { compactSummary } : {}),
@@ -554,6 +727,7 @@ export async function* runChatTurn(input, config = {}) {
         ...(tokenEstimatorResolution.reason ? { tokenEstimatorFallbackReason: tokenEstimatorResolution.reason } : {}),
     });
     const messages = providerContext.messages;
+    const previousCacheDiagnostic = latestCacheDiagnostic(sessionEvents);
     if (planExecutionApproval) {
         messages.push({ role: 'user', content: buildPlanExecutionApprovalPrompt(input, planExecutionApproval, responseLanguage) });
     }
@@ -589,7 +763,6 @@ export async function* runChatTurn(input, config = {}) {
             yield detail ? { ...event, detail } : event;
         }
     }
-    const provider = config.provider ?? createProviderClient(providerConfig, env);
     const pendingHookRuntimeEvents = [];
     let hookCommandSequence = 0;
     const requestToolPermissionWithHooks = async (request, decision) => {
@@ -753,6 +926,10 @@ export async function* runChatTurn(input, config = {}) {
             fullToolRegistry,
             toolDefinitions,
             fullToolDefinitions,
+            contextTrace: providerContext.trace,
+            tokenEstimator: tokenEstimatorResolution.estimator,
+            tokenEstimateProfile: tokenEstimatorResolution.profile,
+            ...(previousCacheDiagnostic ? { previousCacheDiagnostic } : {}),
             skillLoadOptions,
             loadedSkillNames,
             planFirstRequirement,
@@ -773,12 +950,13 @@ export async function* runChatTurn(input, config = {}) {
     }
 }
 export async function* runAgentLoop(scope) {
-    const { input, config, cwd, responseLanguage, provider, resolved, messages, sessionStore, modelEvent, responseStyleEvent, maxTurns, maxToolCalls, toolExecutor, fullToolRegistry, fullToolDefinitions, skillLoadOptions, loadedSkillNames, planFirstRequirement, planExecutionApproval, requiredMutationTools, shouldUseSkillDecisionGuard, hasStopHooks, recalledMemoryRefs, createToolExecutionContext, runGenericHooks, runStopHooks, runStopFailureHooks, flushPendingHookRuntimeEvents, } = scope;
+    const { input, config, cwd, responseLanguage, provider, resolved, messages, sessionStore, modelEvent, responseStyleEvent, maxTurns, maxToolCalls, toolExecutor, fullToolRegistry, fullToolDefinitions, contextTrace, tokenEstimator, tokenEstimateProfile, skillLoadOptions, loadedSkillNames, planFirstRequirement, planExecutionApproval, requiredMutationTools, shouldUseSkillDecisionGuard, hasStopHooks, recalledMemoryRefs, createToolExecutionContext, runGenericHooks, runStopHooks, runStopFailureHooks, flushPendingHookRuntimeEvents, } = scope;
     let activeToolRegistry = scope.activeToolRegistry;
     let toolDefinitions = scope.toolDefinitions;
     let assistantText = '';
     let usage;
     let publishedUsage;
+    let previousCacheDiagnostic = scope.previousCacheDiagnostic;
     let modelTurns = 0;
     let toolCallsUsed = 0;
     let mutationGuardRetries = 0;
@@ -790,6 +968,7 @@ export async function* runAgentLoop(scope) {
     let postActionApprovalGuardRetries = 0;
     let toolArgumentRetries = 0;
     let skillDecisionGuardPrompted = false;
+    let activeDraftPublished = false;
     const planFirstState = createPlanFirstGuardState(planFirstRequirement);
     const mutationState = createMutationGuardState(requiredMutationTools, input);
     const verificationState = createVerificationGuardState();
@@ -802,6 +981,7 @@ export async function* runAgentLoop(scope) {
             modelTurns += 1;
             let turnText = '';
             let turnReasoningText = '';
+            let requestUsage;
             const requestedToolCalls = [];
             const bufferTurnText = shouldBufferMutationText(mutationState) ||
                 shouldGuardMutationClaims(mutationState) ||
@@ -810,6 +990,24 @@ export async function* runAgentLoop(scope) {
                 shouldBufferSkillDecisionGuard(shouldUseSkillDecisionGuard, loadedSkillNames, skillDecisionGuardPrompted) ||
                 hasCurrentTurnActionEvidence(mutationState, verificationState) ||
                 hasStopHooks;
+            const previewBufferedDeltas = Boolean(config.previewBufferedDeltas && bufferTurnText);
+            let turnDraftPublished = false;
+            const discardTurnDraft = function* () {
+                if (!turnDraftPublished) {
+                    return;
+                }
+                turnDraftPublished = false;
+                activeDraftPublished = false;
+                yield { type: 'draft_reset' };
+            };
+            const commitTurnDraft = function* () {
+                if (!turnDraftPublished) {
+                    return;
+                }
+                turnDraftPublished = false;
+                activeDraftPublished = false;
+                yield { type: 'draft_commit' };
+            };
             for await (const chunk of provider.streamChat(messages, resolved, {
                 ...(config.signal ? { signal: config.signal } : {}),
                 timeoutMs: config.timeoutMs ?? defaultTimeoutMs,
@@ -817,6 +1015,7 @@ export async function* runAgentLoop(scope) {
             })) {
                 if (typeof chunk !== 'string') {
                     if (chunk?.type === 'usage') {
+                        requestUsage = mergeTokenUsage(requestUsage, chunk.usage);
                         const nextUsage = mergeTokenUsage(usage, chunk.usage);
                         const usageDelta = tokenUsageDelta(publishedUsage, nextUsage);
                         usage = nextUsage;
@@ -840,27 +1039,55 @@ export async function* runAgentLoop(scope) {
                 if (!bufferTurnText) {
                     yield { type: 'delta', text: chunk };
                 }
+                else if (previewBufferedDeltas) {
+                    turnDraftPublished = true;
+                    activeDraftPublished = true;
+                    yield { type: 'draft_delta', text: chunk };
+                }
+            }
+            if (requestUsage) {
+                const cacheDiagnostic = buildCacheDiagnostic({
+                    messages,
+                    toolDefinitions,
+                    contextTrace,
+                    model: resolved,
+                    turn: modelTurns,
+                    usage: requestUsage,
+                    ...(previousCacheDiagnostic ? { previous: previousCacheDiagnostic } : {}),
+                    tokenEstimator,
+                    tokenEstimateProfile,
+                });
+                sessionStore.append(cacheDiagnostic);
+                previousCacheDiagnostic = {
+                    ...cacheDiagnostic,
+                    sessionId: sessionStore.sessionId,
+                    timestamp: new Date().toISOString(),
+                };
             }
             if (requestedToolCalls.length === 0) {
                 if (shouldRetryMissingPlanFirst(planFirstState, planFirstGuardRetries, modelTurns, maxTurns)) {
                     planFirstGuardRetries += 1;
+                    yield* discardTurnDraft();
                     messages.push({ role: 'user', content: buildPlanFirstGuardPrompt(input, planFirstState, responseLanguage) });
                     continue;
                 }
                 if (shouldFailMissingPlanFirst(planFirstState)) {
                     const message = planFirstGuardFailureMessage(planFirstState);
                     sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield* discardTurnDraft();
                     yield { type: 'error', sessionId: sessionStore.sessionId, message };
                     return;
                 }
                 if (shouldRetryMissingMutationTool(mutationState, mutationGuardRetries, modelTurns, maxTurns)) {
                     mutationGuardRetries += 1;
+                    yield* discardTurnDraft();
                     messages.push({ role: 'user', content: buildMutationGuardPrompt(input, mutationState, responseLanguage) });
                     continue;
                 }
                 if (shouldFailMissingMutationTool(mutationState)) {
                     const message = mutationGuardFailureMessage(mutationState);
                     sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield* discardTurnDraft();
                     yield { type: 'error', sessionId: sessionStore.sessionId, message };
                     return;
                 }
@@ -868,11 +1095,13 @@ export async function* runAgentLoop(scope) {
                 if (mutationClaimIssue) {
                     if (mutationClaimGuardRetries < defaultMutationGuardRetries && modelTurns < maxTurns) {
                         mutationClaimGuardRetries += 1;
+                        yield* discardTurnDraft();
                         messages.push({ role: 'user', content: buildMutationClaimGuardPrompt(input, turnText, mutationState, mutationClaimIssue, responseLanguage) });
                         continue;
                     }
                     const message = mutationClaimGuardFailureMessage(mutationClaimIssue);
                     sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield* discardTurnDraft();
                     yield { type: 'error', sessionId: sessionStore.sessionId, message };
                     return;
                 }
@@ -880,11 +1109,13 @@ export async function* runAgentLoop(scope) {
                 if (verificationClaimIssue) {
                     if (verificationClaimGuardRetries < defaultVerificationClaimGuardRetries && modelTurns < maxTurns) {
                         verificationClaimGuardRetries += 1;
+                        yield* discardTurnDraft();
                         messages.push({ role: 'user', content: buildVerificationClaimGuardPrompt(input, turnText, verificationState, responseLanguage) });
                         continue;
                     }
                     const message = verificationClaimGuardFailureMessage(verificationState);
                     sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield* discardTurnDraft();
                     yield { type: 'error', sessionId: sessionStore.sessionId, message };
                     return;
                 }
@@ -892,21 +1123,25 @@ export async function* runAgentLoop(scope) {
                 if (planFirstClaimIssue) {
                     if (planFirstClaimGuardRetries < defaultPlanFirstGuardRetries && modelTurns < maxTurns) {
                         planFirstClaimGuardRetries += 1;
+                        yield* discardTurnDraft();
                         messages.push({ role: 'user', content: buildPlanFirstClaimGuardPrompt(input, turnText, planFirstState, planFirstClaimIssue, responseLanguage) });
                         continue;
                     }
                     const message = planFirstClaimGuardFailureMessage(planFirstClaimIssue);
                     sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield* discardTurnDraft();
                     yield { type: 'error', sessionId: sessionStore.sessionId, message };
                     return;
                 }
                 if (shouldRetryPlanExecutionApproval(planExecutionApproval, turnText, planExecutionApprovalRetries, modelTurns, maxTurns)) {
                     planExecutionApprovalRetries += 1;
+                    yield* discardTurnDraft();
                     messages.push({ role: 'user', content: buildPlanExecutionApprovalPrompt(input, planExecutionApproval, responseLanguage, true) });
                     continue;
                 }
                 if (shouldRetryPostActionApprovalDraft(turnText, mutationState, verificationState, postActionApprovalGuardRetries, modelTurns, maxTurns)) {
                     postActionApprovalGuardRetries += 1;
+                    yield* discardTurnDraft();
                     messages.push({ role: 'user', content: buildPostActionApprovalGuardPrompt(input, turnText, mutationState, verificationState, responseLanguage) });
                     continue;
                 }
@@ -918,19 +1153,26 @@ export async function* runAgentLoop(scope) {
                     if (stopHookResult.blockingErrors.length > 0) {
                         if (stopHookBlockCount < defaultStopHookBlockRetries && modelTurns < maxTurns) {
                             stopHookBlockCount += 1;
+                            yield* discardTurnDraft();
                             messages.push({ role: 'assistant', content: turnText });
                             messages.push({ role: 'user', content: buildStopHookContinuationPrompt(stopHookResult, responseLanguage) });
                             continue;
                         }
                         const message = stopHookFailureMessage(stopHookResult);
                         sessionStore.append({ type: 'system', level: 'error', content: message });
+                        yield* discardTurnDraft();
                         yield { type: 'error', sessionId: sessionStore.sessionId, message };
                         return;
                     }
                 }
                 assistantText += turnText;
                 if (bufferTurnText && turnText.length > 0) {
-                    yield { type: 'delta', text: turnText };
+                    if (turnDraftPublished) {
+                        yield* commitTurnDraft();
+                    }
+                    else {
+                        yield { type: 'delta', text: turnText };
+                    }
                 }
                 sessionStore.append({
                     type: 'assistant',
@@ -952,9 +1194,11 @@ export async function* runAgentLoop(scope) {
             }
             if (shouldRetrySkillDecisionGuard(shouldUseSkillDecisionGuard, loadedSkillNames, skillDecisionGuardPrompted, requestedToolCalls, modelTurns, maxTurns)) {
                 skillDecisionGuardPrompted = true;
+                yield* discardTurnDraft();
                 messages.push({ role: 'user', content: buildSkillDecisionGuardPrompt(input, requestedToolCalls, responseLanguage) });
                 continue;
             }
+            yield* commitTurnDraft();
             messages.push({
                 role: 'assistant',
                 content: turnText,
@@ -1011,6 +1255,10 @@ export async function* runAgentLoop(scope) {
                 const transcriptArtifacts = hiddenPlanFirstToolCall
                     ? new Map()
                     : appendToolTranscriptEvents(cwd, sessionStore, outcome.transcriptEvents);
+                const pendingAction = hiddenPlanFirstToolCall ? undefined : pendingActionFromToolResult(call, outcome.result);
+                if (pendingAction) {
+                    sessionStore.append(pendingAction);
+                }
                 if (!hiddenPlanFirstToolCall) {
                     recordMutationToolOutcome(mutationState, outcome.toolName, outcome.result, call);
                     recordVerificationToolOutcome(verificationState, outcome.toolName, outcome.result);
@@ -1086,6 +1334,13 @@ export async function* runAgentLoop(scope) {
                         const skillKey = normalizeSkillNameForRuntime(outcome.skill.name);
                         if (!loadedSkillNames.has(skillKey)) {
                             loadedSkillNames.add(skillKey);
+                            sessionStore.append({
+                                type: 'skill_use',
+                                name: outcome.skill.name,
+                                displayName: outcome.skill.displayName,
+                                source: outcome.skill.source,
+                                filePath: outcome.skill.filePath,
+                            });
                             yield {
                                 type: 'skill_use',
                                 name: outcome.skill.name,
@@ -1219,6 +1474,10 @@ export async function* runAgentLoop(scope) {
     }
     catch (error) {
         const message = safeErrorMessage(error);
+        if (activeDraftPublished) {
+            activeDraftPublished = false;
+            yield { type: 'draft_reset' };
+        }
         if (isLlmRequestTimeoutMessage(message) && hasSuccessfulToolResult) {
             const fallbackText = llmTimeoutAfterSuccessfulToolMessage(responseLanguage);
             assistantText = assistantText ? `${assistantText}\n\n${fallbackText}` : fallbackText;
@@ -1549,8 +1808,8 @@ function mergeProjectInstructionSections(...sectionsToMerge) {
     const sections = sectionsToMerge.filter((section) => Boolean(section && section.trim().length > 0));
     return sections.length > 0 ? sections.join('\n\n') : undefined;
 }
-function projectInstructionSource(projectInstructions, hasRecentContext) {
-    return hasRecentContext ? `${projectInstructions.source}; recent context facts` : projectInstructions.source;
+function projectInstructionSource(projectInstructions) {
+    return projectInstructions.source;
 }
 function buildRecentFilesystemContext(events, cwd, env) {
     const recentEvents = events.slice(-maxFilesystemContextEvents);
@@ -1608,6 +1867,162 @@ function buildRecentFilesystemContext(events, cwd, env) {
         'For commands that must run inside one of these projects, set the tool cwd to the mapped absolute project root.',
     ].join('\n');
 }
+function loadRecentSessionSkills(events, options) {
+    const loadedSkills = [];
+    const seen = new Set();
+    for (let index = events.length - 1; index >= 0 && loadedSkills.length < maxRecentLoadedSkills; index -= 1) {
+        const event = events[index];
+        if (!event || event.type !== 'skill_use') {
+            continue;
+        }
+        const key = normalizeSkillNameForRuntime(event.name);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const skill = loadSkillContent({
+            ...options,
+            name: event.name,
+            maxContentChars: maxLoadedSkillContentChars,
+        });
+        if (skill) {
+            loadedSkills.unshift(skill);
+        }
+    }
+    return loadedSkills;
+}
+function buildRecentContinuationContext(events, cwd, env) {
+    const recentEvents = events.slice(-maxRecentContinuationEvents);
+    const toolCalls = new Map();
+    const commandFacts = [];
+    const fileExcerpts = [];
+    const pendingActions = [];
+    const home = typeof env.HOME === 'string' && env.HOME.trim().length > 0 ? normalize(resolve(env.HOME)) : undefined;
+    for (const event of recentEvents) {
+        if (event.type === 'tool_call') {
+            toolCalls.set(event.callId, event);
+            continue;
+        }
+        if (event.type === 'tool_result' && event.ok) {
+            const call = toolCalls.get(event.callId);
+            if (!call) {
+                continue;
+            }
+            const commandFact = formatRecentCommandFact(call, event);
+            if (commandFact) {
+                commandFacts.push(commandFact);
+            }
+            const fileExcerpt = formatRecentFileExcerpt(call, event, cwd, home);
+            if (fileExcerpt) {
+                fileExcerpts.push(fileExcerpt);
+            }
+            continue;
+        }
+    }
+    for (const event of recentEvents) {
+        if (event.type !== 'pending_action') {
+            continue;
+        }
+        const pendingAction = formatPendingActionFact(event);
+        if (pendingAction) {
+            pendingActions.push(pendingAction);
+        }
+    }
+    const recentCommandFacts = uniqueMostRecent(commandFacts, maxRecentToolFacts);
+    const recentFileExcerpts = uniqueMostRecent(fileExcerpts, maxRecentFileExcerpts);
+    const recentPendingActions = uniqueMostRecent(pendingActions, 2);
+    if (recentCommandFacts.length === 0 && recentFileExcerpts.length === 0 && recentPendingActions.length === 0) {
+        return undefined;
+    }
+    return [
+        '## Recent Tool Continuation Facts',
+        'These records come from recent Remi tool activity in this session. They may be stale if the external state changed after the recorded tool result.',
+        ...(recentPendingActions.length > 0
+            ? [
+                '',
+                'Pending external actions:',
+                ...recentPendingActions,
+            ]
+            : []),
+        ...(recentCommandFacts.length > 0 ? ['', 'Recent successful commands:', ...recentCommandFacts] : []),
+        ...(recentFileExcerpts.length > 0 ? ['', 'Recent file excerpts:', ...recentFileExcerpts] : []),
+    ].join('\n');
+}
+function formatRecentCommandFact(call, result) {
+    if (call.toolName !== 'run_command' && call.toolName !== 'execute_shell') {
+        return undefined;
+    }
+    const command = typeof call.input['command'] === 'string' ? call.input['command'].trim() : '';
+    if (!command) {
+        return undefined;
+    }
+    return `- ${call.toolName}: ${compactText(command, 220)} => ${compactText(result.summary, 220)}`;
+}
+function formatRecentFileExcerpt(call, result, cwd, home) {
+    if (call.toolName !== 'read_file' || !result.artifact) {
+        return undefined;
+    }
+    const output = readToolResultArtifactContent(result.artifact);
+    if (!output) {
+        return undefined;
+    }
+    const parsed = parseToolOutput(output);
+    if (!parsed || typeof parsed['content'] !== 'string') {
+        return undefined;
+    }
+    const rawPath = typeof parsed['path'] === 'string' ? parsed['path'] : typeof call.input['path'] === 'string' ? call.input['path'] : '';
+    if (!rawPath) {
+        return undefined;
+    }
+    const normalizedPath = normalizeFilesystemCandidate(rawPath, home) ?? normalize(resolve(cwd, rawPath));
+    if (isSensitiveFilesystemCandidate(normalizedPath)) {
+        return undefined;
+    }
+    const content = truncateText(parsed['content'], maxRecentFileExcerptChars);
+    return [`- ${normalizedPath}`, '  ```', indentContinuationContextBlock(content), '  ```'].join('\n');
+}
+function readToolResultArtifactContent(artifact) {
+    try {
+        const parsed = JSON.parse(readFileSync(artifact.path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const record = parsed;
+        return typeof record['content'] === 'string' ? record['content'] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function indentContinuationContextBlock(text) {
+    return text
+        .replace(/\r\n/g, '\n')
+        .split('\n')
+        .map(line => `  ${line}`)
+        .join('\n');
+}
+function formatPendingActionFact(event) {
+    const lines = [`- ${event.sourceToolName} call ${event.callId}`];
+    if (event.command) {
+        lines.push(`  Original command: ${compactText(event.command, 260)}`);
+    }
+    if (event.completionCommand) {
+        lines.push(`  Completion command: ${compactText(event.completionCommand, 360)}`);
+    }
+    else if (event.tokenName && event.token) {
+        lines.push(`  ${event.tokenName}: ${event.token}`);
+    }
+    if (event.url) {
+        lines.push(`  URL: ${event.url}`);
+    }
+    if (event.qrImagePath) {
+        lines.push(`  QR image: ${event.qrImagePath}`);
+    }
+    if (event.message) {
+        lines.push(`  Note: ${compactText(event.message, 220)}`);
+    }
+    return lines.length > 1 ? lines.join('\n') : undefined;
+}
 function buildRecentFailedToolContext(events) {
     const failedTurns = [];
     let currentTurn;
@@ -2693,7 +3108,15 @@ function toolDefinitionsForProvider(registry, extraTools = []) {
             description: tool.description,
             parameters: tool.inputSchema,
         })),
-    ];
+    ]
+        .map(tool => ({
+        ...tool,
+        parameters: stableJson(tool.parameters),
+    }))
+        .sort(compareToolDefinitions);
+}
+function compareToolDefinitions(left, right) {
+    return left.name.localeCompare(right.name) || left.description.localeCompare(right.description);
 }
 function coreToolDefinitionsForProvider(index, config) {
     const definitions = [];
@@ -3442,6 +3865,180 @@ function summarizeToolDetail(result) {
     }
     return undefined;
 }
+function pendingActionFromToolResult(call, result) {
+    if (!result.ok || (result.toolName !== 'run_command' && result.toolName !== 'execute_shell')) {
+        return undefined;
+    }
+    const parsed = parseToolOutput(result.output);
+    if (!parsed || typeof parsed['command'] !== 'string') {
+        return undefined;
+    }
+    const command = parsed['command'].trim();
+    const stdout = typeof parsed['stdout'] === 'string' ? parsed['stdout'] : '';
+    const stderr = typeof parsed['stderr'] === 'string' ? parsed['stderr'] : '';
+    const combinedOutput = joinCommandOutput(stdout, stderr);
+    const structuredRecords = structuredObjectsFromText(combinedOutput);
+    const token = firstStringFromRecords(structuredRecords, pendingActionTokenKeys()) ?? tokenFromText(combinedOutput);
+    const tokenName = token ? tokenNameFromRecords(structuredRecords, pendingActionTokenKeys()) ?? tokenNameFromText(combinedOutput) ?? 'token' : undefined;
+    const url = firstStringFromRecords(structuredRecords, pendingActionUrlKeys()) ?? urlFromText(combinedOutput);
+    const qrImagePath = firstStringFromRecords(structuredRecords, ['qr_image_path', 'qrImagePath']) ?? qrImagePathFromRecords(structuredRecords);
+    const message = firstStringFromRecords(structuredRecords, ['message', 'title', 'hint']);
+    const completionCommand = completionCommandFromText(combinedOutput) ?? deriveCompletionCommand(command, token);
+    if (!completionCommand && !token && !pendingActionSignal(command, combinedOutput, url)) {
+        return undefined;
+    }
+    const action = {
+        type: 'pending_action',
+        callId: call.id,
+        sourceToolName: result.toolName,
+        command,
+        ...(completionCommand ? { completionCommand } : {}),
+        ...(tokenName ? { tokenName } : {}),
+        ...(token ? { token } : {}),
+        ...(url ? { url } : {}),
+        ...(qrImagePath ? { qrImagePath } : {}),
+        ...(message ? { message: compactText(message, 300) } : {}),
+    };
+    return action;
+}
+function pendingActionTokenKeys() {
+    return ['complete_token', 'resume_token', 'continuation_token', 'poll_token', 'device_code', 'user_code'];
+}
+function pendingActionUrlKeys() {
+    return ['verification_uri_complete', 'verification_url', 'authorization_url', 'authorize_url', 'login_url', 'url', 'open_url'];
+}
+function structuredObjectsFromText(text) {
+    const records = [];
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                records.push(parsed);
+            }
+        }
+        catch {
+            // Non-JSON output is handled by regex fallback extractors below.
+        }
+    }
+    return records;
+}
+function firstStringFromRecords(records, keys) {
+    for (const record of records) {
+        const value = findNestedString(record, keys);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function tokenNameFromRecords(records, keys) {
+    for (const record of records) {
+        const key = findNestedStringKey(record, keys);
+        if (key) {
+            return key;
+        }
+    }
+    return undefined;
+}
+function findNestedString(value, keys, depth = 0) {
+    if (!value || typeof value !== 'object' || depth > 4) {
+        return undefined;
+    }
+    const record = value;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate.trim();
+        }
+    }
+    for (const nested of Object.values(record)) {
+        const candidate = findNestedString(nested, keys, depth + 1);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function findNestedStringKey(value, keys, depth = 0) {
+    if (!value || typeof value !== 'object' || depth > 4) {
+        return undefined;
+    }
+    const record = value;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return key;
+        }
+    }
+    for (const nested of Object.values(record)) {
+        const candidate = findNestedStringKey(nested, keys, depth + 1);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function tokenFromText(text) {
+    const match = text.match(/\b(?:complete[_-]?token|resume[_-]?token|continuation[_-]?token|poll[_-]?token|device[_-]?code|user[_-]?code)\b["':=\s]+([A-Za-z0-9._:-]{6,})/i);
+    return match?.[1];
+}
+function tokenNameFromText(text) {
+    const match = text.match(/\b(complete[_-]?token|resume[_-]?token|continuation[_-]?token|poll[_-]?token|device[_-]?code|user[_-]?code)\b/i);
+    return match?.[1]?.replace(/-/g, '_');
+}
+function urlFromText(text) {
+    const match = text.match(/https?:\/\/[^\s"'<>]+/i);
+    return match ? trimUrlTrailer(match[0]) : undefined;
+}
+function trimUrlTrailer(url) {
+    return url.replace(/[),.;]+$/g, '');
+}
+function qrImagePathFromRecords(records) {
+    for (const record of records) {
+        const path = findNestedString(record, ['path']);
+        if (path && /(?:qr|auth|login).*\.(?:png|jpg|jpeg)$/i.test(path)) {
+            return path;
+        }
+    }
+    return undefined;
+}
+function completionCommandFromText(text) {
+    const match = text.match(/([^\r\n`]*\b(?:auth|oauth|sso)?\s*login\b[^\r\n`]*--complete\s+\S+[^\r\n`]*)/i);
+    const command = match?.[1]?.trim();
+    return command && command.length < 1_000 ? command : undefined;
+}
+function deriveCompletionCommand(command, token) {
+    if (!token) {
+        return undefined;
+    }
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (/\s--complete(?:\s|$)/.test(trimmed)) {
+        return trimmed;
+    }
+    const safeToken = shellWordForContext(token);
+    if (/\s--begin(?:\s|$)/.test(trimmed)) {
+        return trimmed.replace(/\s--begin(?=\s|$)/, ` --complete ${safeToken}`);
+    }
+    if (/\b(?:auth|oauth|sso)?\s*login\b/i.test(trimmed)) {
+        return `${trimmed} --complete ${safeToken}`;
+    }
+    return undefined;
+}
+function shellWordForContext(value) {
+    return /^[A-Za-z0-9._:/=-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function pendingActionSignal(command, output, url) {
+    return Boolean(url &&
+        (/\b(?:auth|oauth|sso|login|mfa|device|verify|verification)\b/i.test(command) ||
+            /\b(?:action_required|device_code|login_status|pending|verification_uri|authenticate|confirm|scan)\b/i.test(output)));
+}
 function isRecoverableToolProtocolError(result) {
     if (result.ok) {
         return false;
@@ -3534,7 +4131,7 @@ function pathIsUrlRecoveryGuidance(result) {
     return [
         'Do not call filesystem tools for URLs.',
         'Use web_fetch for public http(s) URLs.',
-        'For authenticated internal ByteDance, Feishu, or Lark URLs, load a relevant internal-platform skill such as bytedcli when it is available.',
+        'For authenticated internal document URLs, load a relevant internal-platform skill when one is available.',
     ].join(' ');
 }
 function runCommandRecoveryGuidance(result, call) {