@wangzhizhi/remi 0.0.1-alpha

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

@@ -0,0 +1,2843 @@
+import { loadRemiConfig, normalizePermissionProfile, resolveToolPermissionMode, } from '@remi/config';
+import { buildBaseSystemPrompt, defaultResponseStyleId, resolveResponseStyle, } from './responseStyles.js';
+import { buildProviderContext } from './contextBuilder.js';
+import { buildDirectoryOverviewPrelude } from './directoryOverview.js';
+import { buildProjectInstructionsContext } from './projectInstructions.js';
+import { emptyMemoryRecall, recallRelevantMemories, recordMemoryUse } from '@remi/memory';
+import { compactSession, estimateSessionTokens, estimateTextTokens, eventsAfterLatestCompact, latestCompactSummary, maybeUpdateSessionMemory, readSessionMemory } from '@remi/compact';
+import { formatSkillIndexContext, loadSkillContent, loadSkillIndex } from '@remi/skills';
+export { buildBaseSystemPrompt, buildResponseLanguageSystemPrompt, buildResponseStyleSystemPrompt, defaultResponseStyleId, isResponseStyleId, resolveResponseStyle, responseStylePresets, } from './responseStyles.js';
+export { buildProviderContext, } from './contextBuilder.js';
+export { buildProjectInstructionsContext } from './projectInstructions.js';
+import { createModelRouter, createProviderClient, createTokenEstimatorRegistry, } from '@remi/llm';
+import { readFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
+import { createSessionStore, readSessionEvents, writeToolResultArtifact } from '@remi/sessions';
+import { createReadOnlyDryRunExecutor as createRemiReadOnlyDryRunExecutor, createLocalToolExecutor as createRemiLocalToolExecutor, createBuiltInToolRegistry as createRemiBuiltInToolRegistry, createToolRegistry as createRemiToolRegistry, createReadOnlyFileSystemExecutor as createRemiReadOnlyFileSystemExecutor, readFileTool, listFilesTool, searchTextTool, globTool, todoWriteTool, runCommandTool, } from '@remi/tools';
+export { createReadOnlyDryRunExecutor, createReadOnlyFileSystemExecutor, createReadOnlyToolRegistry, createToolPermissionRequest, createToolRegistry, toolInputSchemaToJsonSchema, toolOutputSchemaToJsonSchema, readOnlyTools, readFileTool, listFilesTool, searchTextTool, globTool, todoWriteTool, createDirectoryTool, editFileTool, writeFileTool, deleteFileTool, runCommandTool, executeShellTool, builtInTools, createBuiltInToolRegistry, createLocalToolExecutor, } from '@remi/tools';
+export const corePackageName = '@remi/core';
+const loadSkillToolName = 'load_skill';
+const maxLoadedSkillContentChars = 24_000;
+const loadSkillTool = {
+    name: loadSkillToolName,
+    description: 'Load the full instructions for one Remi skill from the available skill index. If a listed skill semantically matches the user request, call this before reading files, editing files, running commands, or answering about the task. Do not use it when the match is ambiguous.',
+    inputSchema: {
+        type: 'object',
+        description: 'Load full Remi skill instructions by skill name.',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Skill name from the Remi Skills index, for example code-review.',
+            },
+            reason: {
+                type: 'string',
+                description: 'Optional brief reason why this skill matches the current user request.',
+            },
+        },
+        required: ['name'],
+        additionalProperties: false,
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            ok: { type: 'boolean', description: 'Whether the skill was loaded.' },
+            skill: {
+                type: 'object',
+                description: 'Loaded skill metadata and instructions.',
+                properties: {
+                    name: { type: 'string', description: 'Skill name.' },
+                    displayName: { type: 'string', description: 'User-facing skill name.' },
+                    source: { type: 'string', description: 'Skill source.' },
+                    filePath: { type: 'string', description: 'Absolute SKILL.md path.' },
+                    instructions: { type: 'string', description: 'Full skill instructions.' },
+                },
+                required: ['name', 'displayName', 'source', 'filePath', 'instructions'],
+                additionalProperties: false,
+            },
+        },
+        required: ['ok'],
+        additionalProperties: false,
+    },
+    riskLevel: 'read',
+    permissionPolicy: {
+        mode: 'allow',
+        requirements: ['filesystem-read', 'agent-state'],
+        reason: 'Loads a discovered local skill instruction file into this agent turn.',
+    },
+    outputLimit: { maxBytes: 128 * 1024, truncate: 'tail' },
+};
+const defaultTimeoutMs = 60_000;
+export const defaultMaxTurns = 96;
+export const defaultMaxToolCalls = 128;
+const defaultMaxHistoryMessages = 24;
+const defaultMaxHistoryChars = 24_000;
+const defaultMaxHistoryMessageChars = 8_000;
+const defaultFilesystemContextChars = 4_000;
+const defaultMaxMemoryItems = 5;
+const defaultMaxMemoryChars = 6_000;
+const defaultMutationGuardRetries = 2;
+const defaultVerificationClaimGuardRetries = 2;
+const defaultPlanFirstGuardRetries = 2;
+const defaultToolArgumentRetries = 2;
+const maxIdenticalToolCallsBeforeSuppression = 2;
+const defaultContextSafetyBufferTokens = 2_000;
+const defaultMaxOutputReserveTokens = 8_000;
+const defaultAutoCompactThresholdPercent = 85;
+const maxAutoCompactFailures = 3;
+const maxFilesystemContextEvents = 120;
+const maxFilesystemContextRoots = 8;
+const maxFilesystemContextPaths = 12;
+const toolResultArtifactThresholdBytes = 16 * 1024;
+const recoverableWriteToolProtocolErrors = new Set([
+    'FILE_EXISTS',
+    'FILE_NOT_READ',
+    'FILE_PARTIALLY_READ',
+    'FILE_CHANGED_SINCE_READ',
+    'STRING_NOT_FOUND',
+]);
+const recoverableExplorationToolProtocolErrors = new Set(['PATH_NOT_FOUND']);
+const autoCompactFailuresBySession = new Map();
+const tokenEstimatorRegistry = createTokenEstimatorRegistry();
+export function createAgentToolRegistry() {
+    return createRemiBuiltInToolRegistry();
+}
+export function createAgentPlanModeToolRegistry() {
+    return createRemiToolRegistry([readFileTool, listFilesTool, searchTextTool, globTool, todoWriteTool, runCommandTool]);
+}
+export function createAgentDryRunToolExecutor() {
+    return createRemiReadOnlyDryRunExecutor(createAgentToolRegistry());
+}
+export function createAgentReadOnlyToolExecutor() {
+    return createRemiReadOnlyFileSystemExecutor(createAgentToolRegistry());
+}
+export function createAgentLocalToolExecutor() {
+    return createRemiLocalToolExecutor(createAgentToolRegistry());
+}
+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);
+    const outputReserveTokens = clampInteger(configuredOutputReserve ?? modelOutputReserve, 1_024, Math.max(1_024, Math.floor(contextWindowTokens * 0.4)));
+    const safetyBufferTokens = clampInteger(config.contextSafetyBufferTokens ?? runtimeConfig?.contextSafetyBufferTokens ?? defaultContextSafetyBufferTokens, 0, Math.max(0, Math.floor(contextWindowTokens * 0.2)));
+    const effectiveInputBudgetTokens = Math.max(1_024, contextWindowTokens - outputReserveTokens - safetyBufferTokens);
+    const thresholdPercent = clampInteger(config.autoCompactThresholdPercent ?? runtimeConfig?.autoCompactThresholdPercent ?? defaultAutoCompactThresholdPercent, 50, 98);
+    const autoCompactThresholdTokens = Math.max(512, Math.floor(effectiveInputBudgetTokens * (thresholdPercent / 100)));
+    const system = Math.min(16_000, Math.max(1_024, Math.floor(effectiveInputBudgetTokens * 0.08)));
+    const tool = Math.min(24_000, Math.max(1_024, Math.floor(effectiveInputBudgetTokens * 0.12)));
+    const project = Math.min(charsToTokenBudget(defaultFilesystemContextChars), Math.max(512, Math.floor(effectiveInputBudgetTokens * 0.04)));
+    const memory = Math.min(charsToTokenBudget(config.maxMemoryChars ?? defaultMaxMemoryChars), Math.max(512, Math.floor(effectiveInputBudgetTokens * 0.08)));
+    const session = Math.min(charsToTokenBudget(config.maxSessionMemoryChars ?? 8_000), Math.max(512, Math.floor(effectiveInputBudgetTokens * 0.10)));
+    const compact = Math.min(24_000, Math.max(1_024, Math.floor(effectiveInputBudgetTokens * 0.14)));
+    const current = Math.min(64_000, Math.max(1_024, Math.floor(effectiveInputBudgetTokens * 0.20)));
+    const reserved = system + tool + project + memory + session + compact + current;
+    const recent = Math.max(1_024, effectiveInputBudgetTokens - reserved);
+    const tokenBudgets = {
+        system,
+        tool,
+        project,
+        memory,
+        session,
+        compact,
+        recent,
+        current,
+    };
+    return {
+        contextWindowTokens,
+        effectiveInputBudgetTokens,
+        autoCompactThresholdTokens,
+        tokenBudgets,
+        charBudgets: Object.fromEntries(Object.entries(tokenBudgets).map(([layer, tokens]) => [layer, tokenBudgetToChars(tokens ?? 0)])),
+    };
+}
+function shouldAutoCompactSession(options) {
+    if (!isAutoCompactEnabled(options.config, options.runtimeConfig, options.env)) {
+        return { shouldCompact: false };
+    }
+    const activeEvents = eventsAfterLatestCompact(options.events);
+    if (activeEvents.length < 4) {
+        return { shouldCompact: false };
+    }
+    const failureKey = `${options.cwd}\0${options.sessionId}`;
+    if ((autoCompactFailuresBySession.get(failureKey) ?? 0) >= maxAutoCompactFailures) {
+        return { shouldCompact: false };
+    }
+    const estimatedTokens = estimateSessionTokens(activeEvents) + estimateTextTokens(options.input);
+    if (estimatedTokens < options.budget.autoCompactThresholdTokens) {
+        return { shouldCompact: false };
+    }
+    return {
+        shouldCompact: true,
+        failureKey,
+        maxSummaryChars: tokenBudgetToChars(options.budget.tokenBudgets.compact ?? 6_000),
+    };
+}
+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, {
+            maxSummaryChars: options.maxSummaryChars,
+            trigger: 'auto',
+            strategy: 'deterministic',
+        });
+        autoCompactFailuresBySession.delete(options.failureKey);
+        return {
+            compacted: true,
+            summary: result.summary,
+            estimatedTokens: result.estimatedTokens,
+            sourceEventCount: result.sourceEventCount,
+            trigger: 'auto',
+            strategy: 'deterministic',
+            events: readSessionEvents(options.cwd, options.sessionId),
+        };
+    }
+    catch {
+        autoCompactFailuresBySession.set(options.failureKey, (autoCompactFailuresBySession.get(options.failureKey) ?? 0) + 1);
+        return { compacted: false };
+    }
+}
+function isAutoCompactEnabled(config, runtimeConfig, env) {
+    if (env['REMI_DISABLE_AUTO_COMPACT'] === '1' || env['DISABLE_COMPACT'] === '1') {
+        return false;
+    }
+    return config.autoCompact ?? runtimeConfig?.autoCompact ?? true;
+}
+function defaultMaxHistoryMessagesForBudget(budget) {
+    if (budget.effectiveInputBudgetTokens >= 500_000) {
+        return 120;
+    }
+    if (budget.effectiveInputBudgetTokens >= 120_000) {
+        return 80;
+    }
+    return defaultMaxHistoryMessages;
+}
+function charsToTokenBudget(chars) {
+    return Math.max(1, Math.ceil(chars / 3));
+}
+function tokenBudgetToChars(tokens) {
+    return Math.max(256, Math.floor(tokens * 3.5));
+}
+function clampInteger(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.max(min, Math.min(max, Math.floor(value)));
+}
+export function estimateSessionContextTrace(config = {}) {
+    const cwd = config.cwd ?? process.cwd();
+    const env = config.env ?? process.env;
+    const loaded = loadRemiConfig({ cwd });
+    const router = createModelRouter(loaded.config, env);
+    for (const [role, modelAlias] of Object.entries(config.modelOverrides ?? {})) {
+        if (modelAlias) {
+            router.switchRoleModel(role, modelAlias);
+        }
+    }
+    const resolved = router.resolve('main');
+    const contextBudget = createContextBudget(resolved, config, loaded.config.agent);
+    const tokenEstimatorResolution = tokenEstimatorRegistry.resolve(resolved);
+    const sessionEvents = config.sessionId ? readSessionEvents(cwd, config.sessionId) : [];
+    const sessionEventsForContext = eventsAfterLatestCompact(sessionEvents);
+    const compactSummary = latestCompactSummary(sessionEvents);
+    const sessionMemorySummary = config.disableSessionMemory || !config.sessionId ? undefined : readSessionMemory(cwd, config.sessionId)?.content;
+    const priorMessages = sessionEventsToChatMessages(sessionEventsForContext, {
+        maxMessages: config.maxHistoryMessages ?? defaultMaxHistoryMessagesForBudget(contextBudget),
+        maxChars: config.maxHistoryChars ?? tokenBudgetToChars(contextBudget.tokenBudgets.recent ?? 0),
+    });
+    const responseStyle = resolveResponseStyle(config.responseStyle ?? loaded.config.responseStyle ?? defaultResponseStyleId);
+    const currentUserMessage = config.currentUserMessage ?? '';
+    const responseLanguage = resolveResponseLanguage(currentUserMessage);
+    const projectInstructionsContext = buildProjectInstructionsContext(cwd);
+    const providerContext = buildProviderContext({
+        systemPrompt: buildBaseSystemPrompt(responseStyle.id, responseLanguage),
+        ...(projectInstructionsContext.content ? { projectInstructions: projectInstructionsContext.content } : {}),
+        projectInstructionsSource: projectInstructionsContext.source,
+        ...(sessionMemorySummary ? { sessionMemorySummary } : {}),
+        ...(compactSummary ? { compactSummary } : {}),
+        recentMessages: priorMessages,
+        currentUserMessage,
+        budgets: contextBudget.charBudgets,
+        tokenBudgets: contextBudget.tokenBudgets,
+        contextWindowTokens: contextBudget.contextWindowTokens,
+        effectiveInputBudgetTokens: contextBudget.effectiveInputBudgetTokens,
+        autoCompactThresholdTokens: contextBudget.autoCompactThresholdTokens,
+        tokenEstimator: tokenEstimatorResolution.estimator,
+        tokenEstimatorKind: tokenEstimatorResolution.actualKind,
+        tokenEstimatorRequestedKind: tokenEstimatorResolution.requestedKind,
+        tokenEstimateProfile: tokenEstimatorResolution.profile,
+        tokenEstimatorFallback: tokenEstimatorResolution.fallback,
+        ...(tokenEstimatorResolution.reason ? { tokenEstimatorFallbackReason: tokenEstimatorResolution.reason } : {}),
+    });
+    return providerContext.trace;
+}
+export async function* runChatTurn(input, config = {}) {
+    const cwd = config.cwd ?? process.cwd();
+    const env = config.env ?? process.env;
+    const sessionStore = config.sessionStore ?? createSessionStore(cwd, config.sessionId);
+    const loaded = loadRemiConfig({ cwd });
+    const maxTurns = normalizeMaxTurns(config.maxTurns ?? loaded.config.agent?.maxTurns);
+    const maxToolCalls = normalizeToolCallBudget(config.maxToolCalls ?? loaded.config.agent?.maxToolCalls, defaultMaxToolCalls);
+    const router = createModelRouter(loaded.config, env);
+    for (const [role, modelAlias] of Object.entries(config.modelOverrides ?? {})) {
+        if (modelAlias) {
+            router.switchRoleModel(role, modelAlias);
+        }
+    }
+    let resolved;
+    try {
+        resolved = router.resolve('main');
+    }
+    catch (error) {
+        const message = safeErrorMessage(error);
+        sessionStore.append({ type: 'user', content: input });
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+        return;
+    }
+    const providerConfig = loaded.config.providers?.[resolved.providerAlias];
+    if (!providerConfig) {
+        const message = `Unknown provider alias: ${resolved.providerAlias}`;
+        sessionStore.append({ type: 'user', content: input });
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+        return;
+    }
+    const modelEvent = {
+        profile: resolved.profile,
+        role: resolved.role,
+        alias: resolved.alias,
+        displayName: resolved.displayName ?? resolved.alias,
+        provider: resolved.providerAlias,
+        model: resolved.model,
+        ...(resolved.effort !== undefined ? { effort: resolved.effort } : {}),
+    };
+    const responseStyle = resolveResponseStyle(config.responseStyle ?? loaded.config.responseStyle ?? defaultResponseStyleId);
+    const responseLanguage = resolveResponseLanguage(input);
+    const permissionProfile = config.permissionProfile ?? normalizePermissionProfile(loaded.config.permissions);
+    const toolPermissionMode = config.toolPermissionMode ?? resolveToolPermissionMode(loaded.config.permissions);
+    const responseStyleEvent = {
+        id: responseStyle.id,
+        label: responseStyle.label,
+    };
+    if (maxTurns < 1) {
+        const message = `Maximum model turns reached before starting request (maxTurns=${maxTurns}).`;
+        sessionStore.append({ type: 'user', content: input });
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+        return;
+    }
+    if (resolved.apiKeyStatus === 'missing') {
+        const keyHint = providerConfig.apiKeyEnv ? ` Set ${providerConfig.apiKeyEnv} or run model doctor.` : ' Run model doctor.';
+        const message = `Missing API key for model ${resolved.displayName}.${keyHint}`;
+        sessionStore.append({ type: 'user', content: input });
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+        return;
+    }
+    const contextBudget = createContextBudget(resolved, config, loaded.config.agent);
+    const tokenEstimatorResolution = tokenEstimatorRegistry.resolve(resolved);
+    let sessionEvents = config.sessionStore ? [] : readSessionEvents(cwd, sessionStore.sessionId);
+    if (!config.sessionStore) {
+        const autoCompactDecision = shouldAutoCompactSession({
+            cwd,
+            sessionId: sessionStore.sessionId,
+            input,
+            events: sessionEvents,
+            budget: contextBudget,
+            config,
+            env,
+            ...(loaded.config.agent ? { runtimeConfig: loaded.config.agent } : {}),
+        });
+        if (autoCompactDecision.shouldCompact) {
+            yield { type: 'compact_start', automatic: true, trigger: 'auto' };
+            const autoCompact = performAutoCompactSession({
+                cwd,
+                sessionId: sessionStore.sessionId,
+                failureKey: autoCompactDecision.failureKey,
+                maxSummaryChars: autoCompactDecision.maxSummaryChars,
+            });
+            if (autoCompact.compacted) {
+                yield {
+                    type: 'compact',
+                    summary: autoCompact.summary,
+                    estimatedTokens: autoCompact.estimatedTokens,
+                    sourceEventCount: autoCompact.sourceEventCount,
+                    automatic: true,
+                    trigger: autoCompact.trigger,
+                    strategy: autoCompact.strategy,
+                };
+                sessionEvents = autoCompact.events;
+            }
+            yield { type: 'compact_end', automatic: true, trigger: 'auto', ok: autoCompact.compacted };
+        }
+    }
+    const sessionEventsForContext = config.sessionStore ? [] : eventsAfterLatestCompact(sessionEvents);
+    const compactSummary = latestCompactSummary(sessionEvents);
+    const sessionMemorySummary = config.sessionStore || config.disableSessionMemory ? undefined : readSessionMemory(cwd, sessionStore.sessionId)?.content;
+    const priorMessages = config.sessionStore
+        ? []
+        : sessionEventsToChatMessages(sessionEventsForContext, {
+            maxMessages: config.maxHistoryMessages ?? defaultMaxHistoryMessagesForBudget(contextBudget),
+            maxChars: config.maxHistoryChars ?? tokenBudgetToChars(contextBudget.tokenBudgets.recent ?? 0),
+        });
+    sessionStore.append({ type: 'user', content: input });
+    const planFirstRequirement = config.planMode || config.planFirst === 'off' ? undefined : planFirstRequirementForInput(input, sessionEventsForContext);
+    const planExecutionApproval = config.planMode ? undefined : planExecutionApprovalForInput(input, sessionEventsForContext);
+    const planModeToolRegistry = createAgentPlanModeToolRegistry();
+    const fullToolRegistry = createAgentToolRegistry();
+    const effectivePlanMode = Boolean(config.planMode || planFirstRequirement);
+    const toolExecutor = config.toolExecutor ?? createRemiReadOnlyFileSystemExecutor(fullToolRegistry);
+    const readFileState = new Map();
+    const shouldOfferTools = resolved.supportsTools && shouldOfferToolsForInput(input);
+    const disabledSkills = loaded.config.skills?.disabled;
+    const skillHomeDir = typeof env.HOME === 'string' && env.HOME.trim().length > 0 ? env.HOME : config.env ? cwd : undefined;
+    const skillLoadOptions = {
+        cwd,
+        ...(skillHomeDir ? { homeDir: skillHomeDir } : {}),
+        ...(disabledSkills ? { disabled: disabledSkills } : {}),
+    };
+    const skillIndex = loadSkillIndex(skillLoadOptions);
+    const hasEnabledSkillIndex = skillIndex.skills.some(skill => skill.enabled);
+    const shouldUseSkillDecisionGuard = hasEnabledSkillIndex && !isExplicitSkillInvocationPrompt(input);
+    const fullToolDefinitions = shouldOfferTools ? toolDefinitionsForProvider(fullToolRegistry, skillToolDefinitionsForProvider(skillIndex)) : [];
+    const requiredMutationTools = config.planMode || planFirstRequirement?.executeAfterPlan === false ? [] : requiredMutationToolsForInput(input, fullToolDefinitions);
+    const adaptiveToolRegistry = shouldUseReadOnlyToolSurface(input, planExecutionApproval, requiredMutationTools) ? planModeToolRegistry : fullToolRegistry;
+    let activeToolRegistry = effectivePlanMode ? planModeToolRegistry : adaptiveToolRegistry;
+    let toolDefinitions = shouldOfferTools ? toolDefinitionsForProvider(activeToolRegistry, skillToolDefinitionsForProvider(skillIndex)) : [];
+    const directoryOverviewPrelude = toolDefinitions.length > 0
+        ? await buildDirectoryOverviewPrelude({
+            input,
+            cwd,
+            env,
+            sessionId: sessionStore.sessionId,
+            executor: toolExecutor,
+            ...(config.signal ? { signal: config.signal } : {}),
+        })
+        : undefined;
+    const recentFilesystemContext = toolDefinitions.length > 0 ? buildRecentFilesystemContext(sessionEventsForContext, cwd, env) : undefined;
+    const projectInstructionsContext = buildProjectInstructionsContext(cwd);
+    const loadedSkills = [];
+    const loadedSkillNames = new Set();
+    const skillContext = formatSkillIndexContext(skillIndex);
+    const projectInstructions = mergeProjectInstructionSections(projectInstructionsContext.content, recentFilesystemContext, skillContext);
+    const memoryRecall = config.disableMemory || !shouldOfferMemoryForInput(input)
+        ? emptyMemoryRecall(input, config.maxMemoryItems ?? defaultMaxMemoryItems)
+        : recallRelevantMemories(cwd, input, {
+            limit: config.maxMemoryItems ?? defaultMaxMemoryItems,
+            maxBodyChars: config.maxMemoryChars ?? defaultMaxMemoryChars,
+        });
+    const providerContext = buildProviderContext({
+        systemPrompt: buildBaseSystemPrompt(responseStyle.id, responseLanguage),
+        ...(toolDefinitions.length > 0 ? { toolPrompt: buildToolUseSystemPrompt(cwd, env, planPromptMode(config.planMode, planFirstRequirement), responseLanguage) } : {}),
+        ...(projectInstructions ? { projectInstructions } : {}),
+        projectInstructionsSource: projectInstructionSource(projectInstructionsContext, Boolean(recentFilesystemContext)),
+        memories: memoryRecall.memories,
+        ...(sessionMemorySummary ? { sessionMemorySummary } : {}),
+        ...(compactSummary ? { compactSummary } : {}),
+        recentMessages: [...priorMessages, ...(directoryOverviewPrelude?.messages ?? [])],
+        currentUserMessage: input,
+        budgets: contextBudget.charBudgets,
+        tokenBudgets: contextBudget.tokenBudgets,
+        contextWindowTokens: contextBudget.contextWindowTokens,
+        effectiveInputBudgetTokens: contextBudget.effectiveInputBudgetTokens,
+        autoCompactThresholdTokens: contextBudget.autoCompactThresholdTokens,
+        tokenEstimator: tokenEstimatorResolution.estimator,
+        tokenEstimatorKind: tokenEstimatorResolution.actualKind,
+        tokenEstimatorRequestedKind: tokenEstimatorResolution.requestedKind,
+        tokenEstimateProfile: tokenEstimatorResolution.profile,
+        tokenEstimatorFallback: tokenEstimatorResolution.fallback,
+        ...(tokenEstimatorResolution.reason ? { tokenEstimatorFallbackReason: tokenEstimatorResolution.reason } : {}),
+    });
+    const messages = providerContext.messages;
+    if (planExecutionApproval) {
+        messages.push({ role: 'user', content: buildPlanExecutionApprovalPrompt(input, planExecutionApproval, responseLanguage) });
+    }
+    const recalledMemoryIds = memoryRecall.memories.map(memory => memory.id);
+    yield {
+        type: 'start',
+        sessionId: sessionStore.sessionId,
+        model: modelEvent,
+        responseStyle: responseStyleEvent,
+        contextTrace: providerContext.trace,
+        memoryTrace: memoryRecall.trace,
+    };
+    for (const skill of loadedSkills) {
+        yield {
+            type: 'skill_use',
+            name: skill.name,
+            displayName: skill.displayName,
+            source: skill.source,
+            filePath: skill.filePath,
+        };
+    }
+    if (directoryOverviewPrelude) {
+        for (const { call, result } of directoryOverviewPrelude.toolCalls) {
+            yield { type: 'tool_call', callId: call.id, toolName: call.toolName, summary: summarizeToolCall(call) };
+            const detail = summarizeToolDetail(result);
+            const event = {
+                type: 'tool_result',
+                callId: result.callId,
+                toolName: result.toolName,
+                ok: result.ok,
+                summary: summarizeToolResult(result),
+            };
+            yield detail ? { ...event, detail } : event;
+        }
+    }
+    const provider = config.provider ?? createProviderClient(providerConfig, env);
+    let assistantText = '';
+    let usage;
+    let publishedUsage;
+    let modelTurns = 0;
+    let toolCallsUsed = 0;
+    let mutationGuardRetries = 0;
+    let mutationClaimGuardRetries = 0;
+    let verificationClaimGuardRetries = 0;
+    let planFirstGuardRetries = 0;
+    let planFirstClaimGuardRetries = 0;
+    let planExecutionApprovalRetries = 0;
+    let postActionApprovalGuardRetries = 0;
+    let toolArgumentRetries = 0;
+    let skillDecisionGuardPrompted = false;
+    const planFirstState = createPlanFirstGuardState(planFirstRequirement);
+    const mutationState = createMutationGuardState(requiredMutationTools, input);
+    const verificationState = createVerificationGuardState();
+    const repeatedToolCallState = createRepeatedToolCallState();
+    const guardMutationClaims = shouldGuardMutationClaimsForInput(input, requiredMutationTools);
+    const guardVerificationClaims = shouldGuardVerificationClaimsForInput(input, requiredMutationTools);
+    try {
+        while (modelTurns < maxTurns) {
+            modelTurns += 1;
+            let turnText = '';
+            let turnReasoningText = '';
+            const requestedToolCalls = [];
+            const bufferTurnText = shouldBufferMutationText(mutationState) ||
+                guardMutationClaims ||
+                guardVerificationClaims ||
+                shouldBufferPlanFirstText(planFirstState) ||
+                shouldBufferSkillDecisionGuard(shouldUseSkillDecisionGuard, loadedSkillNames, skillDecisionGuardPrompted) ||
+                hasCurrentTurnActionEvidence(mutationState, verificationState);
+            for await (const chunk of provider.streamChat(messages, resolved, {
+                ...(config.signal ? { signal: config.signal } : {}),
+                timeoutMs: config.timeoutMs ?? defaultTimeoutMs,
+                ...(toolDefinitions.length > 0 ? { tools: toolDefinitions } : {}),
+            })) {
+                if (typeof chunk !== 'string') {
+                    if (chunk?.type === 'usage') {
+                        const nextUsage = mergeTokenUsage(usage, chunk.usage);
+                        const usageDelta = tokenUsageDelta(publishedUsage, nextUsage);
+                        usage = nextUsage;
+                        if (hasTokenUsage(usageDelta)) {
+                            publishedUsage = nextUsage;
+                            yield { type: 'usage', usage: usageDelta };
+                        }
+                    }
+                    else if (chunk?.type === 'reasoning_delta') {
+                        turnReasoningText += chunk.text;
+                    }
+                    else if (chunk?.type === 'tool_call') {
+                        requestedToolCalls.push(chunk.toolCall);
+                    }
+                    continue;
+                }
+                if (chunk.length === 0) {
+                    continue;
+                }
+                turnText += chunk;
+                if (!bufferTurnText) {
+                    yield { type: 'delta', text: chunk };
+                }
+            }
+            if (requestedToolCalls.length === 0) {
+                if (shouldRetryMissingPlanFirst(planFirstState, planFirstGuardRetries, modelTurns, maxTurns)) {
+                    planFirstGuardRetries += 1;
+                    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 { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                if (shouldRetryMissingMutationTool(mutationState, mutationGuardRetries, modelTurns, maxTurns)) {
+                    mutationGuardRetries += 1;
+                    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 { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                const mutationClaimIssue = guardMutationClaims ? mutationCompletionClaimIssue(turnText, mutationState) : undefined;
+                if (mutationClaimIssue) {
+                    if (mutationClaimGuardRetries < defaultMutationGuardRetries && modelTurns < maxTurns) {
+                        mutationClaimGuardRetries += 1;
+                        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 { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                const verificationClaimIssue = guardVerificationClaims ? verificationClaimGuardIssue(turnText, verificationState) : undefined;
+                if (verificationClaimIssue) {
+                    if (verificationClaimGuardRetries < defaultVerificationClaimGuardRetries && modelTurns < maxTurns) {
+                        verificationClaimGuardRetries += 1;
+                        messages.push({ role: 'user', content: buildVerificationClaimGuardPrompt(input, turnText, verificationState, responseLanguage) });
+                        continue;
+                    }
+                    const message = verificationClaimGuardFailureMessage(verificationState);
+                    sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                const planFirstClaimIssue = planFirstCompletionClaimIssue(turnText, planFirstState);
+                if (planFirstClaimIssue) {
+                    if (planFirstClaimGuardRetries < defaultPlanFirstGuardRetries && modelTurns < maxTurns) {
+                        planFirstClaimGuardRetries += 1;
+                        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 { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                if (shouldRetryPlanExecutionApproval(planExecutionApproval, turnText, planExecutionApprovalRetries, modelTurns, maxTurns)) {
+                    planExecutionApprovalRetries += 1;
+                    messages.push({ role: 'user', content: buildPlanExecutionApprovalPrompt(input, planExecutionApproval, responseLanguage, true) });
+                    continue;
+                }
+                if (shouldRetryPostActionApprovalDraft(turnText, mutationState, verificationState, postActionApprovalGuardRetries, modelTurns, maxTurns)) {
+                    postActionApprovalGuardRetries += 1;
+                    messages.push({ role: 'user', content: buildPostActionApprovalGuardPrompt(input, turnText, mutationState, verificationState, responseLanguage) });
+                    continue;
+                }
+                assistantText += turnText;
+                if (bufferTurnText && turnText.length > 0) {
+                    yield { type: 'delta', text: turnText };
+                }
+                sessionStore.append({
+                    type: 'assistant',
+                    content: assistantText,
+                    model: modelEvent,
+                    style: responseStyleEvent,
+                    ...(usage ? { usage } : {}),
+                });
+                recordRecalledMemoryUse(cwd, recalledMemoryIds);
+                recordSessionMemoryIfNeeded(cwd, sessionStore.sessionId, config);
+                yield {
+                    type: 'done',
+                    text: assistantText,
+                    sessionId: sessionStore.sessionId,
+                    sessionPath: sessionStore.sessionPath,
+                    ...(usage ? { usage } : {}),
+                };
+                return;
+            }
+            if (shouldRetrySkillDecisionGuard(shouldUseSkillDecisionGuard, loadedSkillNames, skillDecisionGuardPrompted, requestedToolCalls, modelTurns, maxTurns)) {
+                skillDecisionGuardPrompted = true;
+                messages.push({ role: 'user', content: buildSkillDecisionGuardPrompt(input, requestedToolCalls, responseLanguage) });
+                continue;
+            }
+            messages.push({
+                role: 'assistant',
+                content: turnText,
+                ...(turnReasoningText.length > 0 ? { reasoningContent: turnReasoningText } : {}),
+                toolCalls: requestedToolCalls,
+            });
+            let pendingConcurrentToolExecutions = [];
+            const createToolExecutionContext = () => ({
+                cwd,
+                sessionId: sessionStore.sessionId,
+                maxOutputBytes: 128 * 1024,
+                ...(config.signal ? { signal: config.signal } : {}),
+                permissionMode: toolPermissionMode,
+                permissionProfile,
+                allowedReadRoots: allowedReadRoots(cwd, env),
+                allowedWriteRoots: allowedWriteRoots(cwd, env),
+                permissionRules: latestPermissionRules(cwd, env, runtimePermissionRules(config.permissionRules)),
+                ...(config.requestToolPermission ? { requestPermission: config.requestToolPermission } : {}),
+                readFileState,
+            });
+            const executePreparedToolCall = async (prepared) => {
+                const outcome = prepared.hiddenPlanFirstToolCall
+                    ? planFirstUnavailableToolOutcome(prepared.call)
+                    : prepared.repeatedToolCallOutcome
+                        ? prepared.repeatedToolCallOutcome
+                        : await toolExecutor.execute({
+                            call: prepared.call,
+                            context: createToolExecutionContext(),
+                        });
+                return { ...prepared, outcome };
+            };
+            const publishCompletedToolCall = function* (completed) {
+                const { requestedToolCall, call, hiddenPlanFirstToolCall, outcome } = completed;
+                const transcriptArtifacts = hiddenPlanFirstToolCall
+                    ? new Map()
+                    : appendToolTranscriptEvents(cwd, sessionStore, outcome.transcriptEvents);
+                if (!hiddenPlanFirstToolCall) {
+                    recordMutationToolOutcome(mutationState, outcome.toolName, outcome.result, call);
+                    recordVerificationToolOutcome(verificationState, outcome.toolName, outcome.result);
+                }
+                const detail = summarizeToolDetail(outcome.result);
+                const artifact = transcriptArtifacts.get(outcome.callId);
+                const event = {
+                    type: 'tool_result',
+                    callId: outcome.callId,
+                    toolName: outcome.toolName,
+                    ok: outcome.result.ok,
+                    summary: summarizeToolResult(outcome.result),
+                    ...(isRecoverableToolProtocolError(outcome.result) || hiddenPlanFirstToolCall ? { recoverable: true } : {}),
+                    ...(artifact ? { artifact } : {}),
+                };
+                const planItems = planItemsFromToolResult(outcome.result);
+                if (planItems) {
+                    const continueAfterPlan = recordPlanFirstToolOutcome(planFirstState);
+                    yield { type: 'plan_update', callId: outcome.callId, items: planItems };
+                    if (continueAfterPlan) {
+                        activeToolRegistry = fullToolRegistry;
+                        toolDefinitions = fullToolDefinitions;
+                    }
+                }
+                else if (hiddenPlanFirstToolCall) {
+                    yield event;
+                }
+                else {
+                    yield detail ? { ...event, detail } : event;
+                }
+                messages.push({
+                    role: 'tool',
+                    toolCallId: requestedToolCall.id,
+                    content: toolResultMessageContent(outcome.result, call),
+                });
+                if (planItems && planFirstState.requirement?.executeAfterPlan) {
+                    messages.push({ role: 'user', content: buildPlanFirstContinuationPrompt(input, responseLanguage) });
+                }
+                else if (planItems && planExecutionApproval) {
+                    messages.push({ role: 'user', content: buildPlanExecutionApprovalPrompt(input, planExecutionApproval, responseLanguage, true) });
+                }
+            };
+            const flushConcurrentToolExecutions = async function* () {
+                if (pendingConcurrentToolExecutions.length === 0) {
+                    return;
+                }
+                const batch = pendingConcurrentToolExecutions;
+                pendingConcurrentToolExecutions = [];
+                for (const prepared of batch) {
+                    yield { type: 'tool_call', callId: prepared.call.id, toolName: prepared.call.toolName, summary: summarizeToolCall(prepared.call) };
+                }
+                const completedBatch = await Promise.all(batch.map(executePreparedToolCall));
+                for (const completed of completedBatch) {
+                    yield* publishCompletedToolCall(completed);
+                }
+            };
+            for (const requestedToolCall of requestedToolCalls) {
+                if (toolCallsUsed >= maxToolCalls) {
+                    yield* flushConcurrentToolExecutions();
+                    const message = toolBudgetExhaustedMessage(toolCallsUsed, maxToolCalls);
+                    sessionStore.append({ type: 'system', level: 'error', content: message });
+                    yield { type: 'error', sessionId: sessionStore.sessionId, message };
+                    return;
+                }
+                toolCallsUsed += 1;
+                if (requestedToolCall.name === loadSkillToolName) {
+                    yield* flushConcurrentToolExecutions();
+                    const outcome = loadSkillToolCallOutcome(requestedToolCall, skillLoadOptions);
+                    if (outcome.skill) {
+                        const skillKey = normalizeSkillNameForRuntime(outcome.skill.name);
+                        if (!loadedSkillNames.has(skillKey)) {
+                            loadedSkillNames.add(skillKey);
+                            yield {
+                                type: 'skill_use',
+                                name: outcome.skill.name,
+                                displayName: outcome.skill.displayName,
+                                source: outcome.skill.source,
+                                filePath: outcome.skill.filePath,
+                            };
+                        }
+                    }
+                    messages.push({
+                        role: 'tool',
+                        toolCallId: requestedToolCall.id,
+                        content: toolResultMessageContent(outcome.result),
+                    });
+                    continue;
+                }
+                const parsedToolCall = toolCallFromLLM(requestedToolCall, activeToolRegistry);
+                if (!parsedToolCall.ok) {
+                    yield* flushConcurrentToolExecutions();
+                    if (toolArgumentRetries >= defaultToolArgumentRetries || modelTurns >= maxTurns) {
+                        const message = toolArgumentFailureMessage(toolArgumentRetries, parsedToolCall.result);
+                        sessionStore.append({ type: 'system', level: 'error', content: message });
+                        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+                        return;
+                    }
+                    toolArgumentRetries += 1;
+                    const outcome = invalidToolArgumentsOutcome(requestedToolCall, parsedToolCall.result);
+                    yield {
+                        type: 'tool_call',
+                        callId: outcome.callId,
+                        toolName: outcome.toolName,
+                        summary: summarizeInvalidToolArgumentsCall(requestedToolCall),
+                    };
+                    appendToolTranscriptEvents(cwd, sessionStore, outcome.transcriptEvents);
+                    yield {
+                        type: 'tool_result',
+                        callId: outcome.callId,
+                        toolName: outcome.toolName,
+                        ok: false,
+                        summary: summarizeToolResult(outcome.result),
+                        recoverable: true,
+                    };
+                    messages.push({
+                        role: 'tool',
+                        toolCallId: requestedToolCall.id,
+                        content: toolResultMessageContent(outcome.result),
+                    });
+                    continue;
+                }
+                const call = parsedToolCall.call;
+                const hiddenPlanFirstToolCall = isHiddenPlanFirstToolCall(call, planFirstState, activeToolRegistry);
+                const repeatedToolCallOutcome = hiddenPlanFirstToolCall
+                    ? undefined
+                    : maybeRepeatedToolCallOutcome(call, activeToolRegistry, repeatedToolCallState);
+                const preparedToolCall = {
+                    requestedToolCall,
+                    call,
+                    hiddenPlanFirstToolCall,
+                    ...(repeatedToolCallOutcome ? { repeatedToolCallOutcome } : {}),
+                };
+                if (isConcurrentReadOnlyToolCall(call, activeToolRegistry) && !hiddenPlanFirstToolCall && !repeatedToolCallOutcome) {
+                    pendingConcurrentToolExecutions.push(preparedToolCall);
+                    continue;
+                }
+                yield* flushConcurrentToolExecutions();
+                if (!hiddenPlanFirstToolCall) {
+                    yield { type: 'tool_call', callId: call.id, toolName: call.toolName, summary: summarizeToolCall(call) };
+                }
+                yield* publishCompletedToolCall(await executePreparedToolCall(preparedToolCall));
+            }
+            yield* flushConcurrentToolExecutions();
+        }
+        const message = `Maximum model turns reached (maxTurns=${maxTurns}).`;
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+    }
+    catch (error) {
+        const message = safeErrorMessage(error);
+        sessionStore.append({ type: 'system', level: 'error', content: message });
+        yield { type: 'error', sessionId: sessionStore.sessionId, message };
+    }
+}
+function normalizeMaxTurns(maxTurns) {
+    if (maxTurns === undefined) {
+        return defaultMaxTurns;
+    }
+    if (!Number.isFinite(maxTurns)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(maxTurns));
+}
+function normalizeToolCallBudget(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.floor(value));
+}
+function toolBudgetExhaustedMessage(toolCallsUsed, maxToolCalls) {
+    return `Tool budget exhausted after ${toolCallsUsed} tool calls (maxToolCalls=${maxToolCalls}). Partial work is preserved; ask Remi to continue from this session.`;
+}
+function isConcurrentReadOnlyToolCall(call, registry) {
+    const tool = registry.get(call.toolName);
+    return (tool?.riskLevel === 'read' &&
+        tool.permissionPolicy.requirements.length === 1 &&
+        tool.permissionPolicy.requirements[0] === 'filesystem-read');
+}
+function sessionEventsToChatMessages(events, options = {}) {
+    const candidates = [];
+    let pendingUser;
+    for (const event of events) {
+        if (event.type === 'user') {
+            pendingUser = event.content;
+            continue;
+        }
+        if (event.type === 'assistant') {
+            if (pendingUser !== undefined) {
+                candidates.push({ role: 'user', content: pendingUser });
+                pendingUser = undefined;
+            }
+            candidates.push({ role: 'assistant', content: event.content });
+            continue;
+        }
+        if (event.type === 'system' && event.level === 'error') {
+            pendingUser = undefined;
+        }
+    }
+    return selectRecentHistoryMessages(candidates, {
+        maxMessages: normalizePositiveLimit(options.maxMessages, defaultMaxHistoryMessages),
+        maxChars: normalizePositiveLimit(options.maxChars, defaultMaxHistoryChars),
+    });
+}
+function selectRecentHistoryMessages(messages, options) {
+    const selected = [];
+    let usedChars = 0;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (selected.length >= options.maxMessages || usedChars >= options.maxChars) {
+            break;
+        }
+        const message = messages[index];
+        if (!message || message.role === 'system' || message.role === 'tool') {
+            continue;
+        }
+        const remainingChars = options.maxChars - usedChars;
+        const contentBudget = Math.min(defaultMaxHistoryMessageChars, remainingChars);
+        if (contentBudget <= 0) {
+            break;
+        }
+        const content = truncateHistoryContent(message.content, contentBudget);
+        usedChars += content.length;
+        selected.push({ role: message.role, content });
+    }
+    return selected.reverse();
+}
+function truncateHistoryContent(content, maxChars) {
+    if (content.length <= maxChars) {
+        return content;
+    }
+    if (maxChars <= 64) {
+        return content.slice(Math.max(0, content.length - maxChars));
+    }
+    const notice = '[Earlier message content omitted to stay within Remi context budget.]\n';
+    return `${notice}${content.slice(Math.max(0, content.length - (maxChars - notice.length)))}`;
+}
+function normalizePositiveLimit(value, fallback) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.floor(value));
+}
+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, hasRecentFilesystemContext) {
+    return hasRecentFilesystemContext ? `${projectInstructions.source}; recent filesystem facts` : projectInstructions.source;
+}
+function buildRecentFilesystemContext(events, cwd, env) {
+    const recentEvents = events.slice(-maxFilesystemContextEvents);
+    const successfulCallIds = new Set(recentEvents
+        .filter((event) => event.type === 'tool_result' && event.ok)
+        .map(event => event.callId));
+    const rawCandidates = [];
+    const pushCandidate = (value) => {
+        rawCandidates.push(value);
+    };
+    for (const event of recentEvents) {
+        if (event.type === 'tool_call' && successfulCallIds.has(event.callId)) {
+            collectPathCandidates(event.input, pushCandidate);
+            continue;
+        }
+        if (event.type === 'tool_result' && event.ok) {
+            collectPathCandidatesFromToolResult(event.summary, pushCandidate);
+        }
+    }
+    const home = typeof env.HOME === 'string' && env.HOME.trim().length > 0 ? normalize(resolve(env.HOME)) : undefined;
+    const normalizedCwd = normalize(resolve(cwd));
+    const absolutePaths = uniqueMostRecent(rawCandidates
+        .map(candidate => normalizeFilesystemCandidate(candidate, home))
+        .filter((candidate) => Boolean(candidate))
+        .filter(candidate => !isSensitiveFilesystemCandidate(candidate))
+        .filter(candidate => !isPathInsideOrEqual(candidate, normalizedCwd)), maxFilesystemContextPaths);
+    if (absolutePaths.length === 0) {
+        return undefined;
+    }
+    const roots = uniqueMostRecent(absolutePaths
+        .map(path => inferFilesystemRoot(path, home))
+        .filter((root) => Boolean(root))
+        .filter(root => !isPathInsideOrEqual(root, normalizedCwd)), maxFilesystemContextRoots);
+    const aliasCounts = countAliases(roots);
+    const rootLines = roots.map(root => {
+        const alias = basename(root);
+        return aliasCounts.get(alias) === 1 ? `- ${alias} => ${root}` : `- ${root}`;
+    });
+    const pathLines = absolutePaths
+        .filter(path => !roots.some(root => path === root))
+        .slice(0, maxFilesystemContextPaths)
+        .map(path => `- ${path}`);
+    return [
+        '## Recent Filesystem Locations',
+        'These path facts come from recent successful Remi tool activity in this session.',
+        'Use them when the user refers again to a project or directory by name without restating its absolute path.',
+        ...(rootLines.length > 0 ? ['', 'Known project roots:', ...rootLines] : []),
+        ...(pathLines.length > 0 ? ['', 'Recent absolute paths:', ...pathLines] : []),
+        '',
+        `Current Remi runtime cwd: ${normalizedCwd}`,
+        'Do not create a new directory with the same historical project name under the runtime cwd unless the user explicitly asks for the Remi repository.',
+        'For commands that must run inside one of these projects, set the tool cwd to the mapped absolute project root.',
+    ].join('\n');
+}
+function collectPathCandidates(value, push, key = '', depth = 0) {
+    if (depth > 4) {
+        return;
+    }
+    if (typeof value === 'string') {
+        if (isPathLikeKey(key)) {
+            push(value);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value.slice(0, 50)) {
+            collectPathCandidates(item, push, key, depth + 1);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    for (const [childKey, childValue] of Object.entries(value)) {
+        collectPathCandidates(childValue, push, childKey, depth + 1);
+    }
+}
+function collectPathCandidatesFromToolResult(summary, push) {
+    const parsed = parseJsonObject(summary);
+    if (parsed !== undefined) {
+        collectPathCandidates(parsed, push);
+        return;
+    }
+    for (const match of summary.matchAll(/(?:~\/|\/Users\/|\/private\/|\/tmp\/|\/var\/)[^\s"'`<>|]+/g)) {
+        if (match[0]) {
+            push(match[0]);
+        }
+    }
+}
+function parseJsonObject(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPathLikeKey(key) {
+    return key === 'path' || key === 'cwd' || key.endsWith('Path');
+}
+function normalizeFilesystemCandidate(raw, home) {
+    const trimmed = raw.trim().replace(/^[("'`]+/g, '').replace(/[)"'`,.;:\]}]+$/g, '');
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    if (trimmed === '~') {
+        return home;
+    }
+    if (trimmed.startsWith('~/')) {
+        return home ? normalize(resolve(home, trimmed.slice(2))) : undefined;
+    }
+    return isAbsolute(trimmed) ? normalize(resolve(trimmed)) : undefined;
+}
+function inferFilesystemRoot(path, home) {
+    if (home) {
+        const desktop = normalize(join(home, 'Desktop'));
+        if (isPathInsideOrEqual(path, desktop)) {
+            const rel = relative(desktop, path);
+            const firstSegment = rel.split(sep).filter(Boolean)[0];
+            return firstSegment ? normalize(join(desktop, firstSegment)) : desktop;
+        }
+    }
+    const name = basename(path);
+    return name.includes('.') ? dirname(path) : path;
+}
+function countAliases(paths) {
+    const counts = new Map();
+    for (const path of paths) {
+        const alias = basename(path);
+        counts.set(alias, (counts.get(alias) ?? 0) + 1);
+    }
+    return counts;
+}
+function uniqueMostRecent(values, limit) {
+    const selected = [];
+    const seen = new Set();
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const value = values[index];
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        selected.unshift(value);
+        if (selected.length >= limit) {
+            break;
+        }
+    }
+    return selected;
+}
+function isPathInsideOrEqual(target, root) {
+    const rel = relative(root, target);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function isSensitiveFilesystemCandidate(path) {
+    const lowerName = basename(path).toLowerCase();
+    return (lowerName === '.env' ||
+        lowerName.startsWith('.env.') ||
+        lowerName === '.npmrc' ||
+        lowerName === '.netrc' ||
+        lowerName.includes('token') ||
+        lowerName.includes('secret') ||
+        lowerName.endsWith('.pem') ||
+        lowerName.endsWith('.key'));
+}
+function shouldOfferToolsForInput(input) {
+    const normalized = normalizeIntentText(input);
+    if (normalized.length === 0) {
+        return false;
+    }
+    if (isTextOnlyPlanRequest(normalized)) {
+        return false;
+    }
+    return !/^(你好|您好|嗨|哈喽|hello|hi|hey|thanks|thank you|谢谢|多谢|测试|test)$/.test(normalized);
+}
+function shouldUseReadOnlyToolSurface(input, planExecutionApproval, requiredMutationTools) {
+    const normalized = normalizeIntentText(input);
+    if (!shouldOfferToolsForInput(input) || normalized.length === 0) {
+        return false;
+    }
+    if (planExecutionApproval || requiredMutationTools.length > 0) {
+        return false;
+    }
+    if (isAdvisoryOnlyRequest(normalized) || isTextOnlyPlanRequest(normalized)) {
+        return true;
+    }
+    if (fullToolSurfaceIntentPattern().test(normalized)) {
+        return false;
+    }
+    return readOnlyToolSurfaceIntentPattern().test(normalized);
+}
+function readOnlyToolSurfaceIntentPattern() {
+    return /(看一下|看看|查看|读取|读一下|列出|打开|搜索|查找|解释|说明|总结|分析|审查|看看有什么|有什么东西)|\b(?:read|show|list|open|search|find|inspect|explain|summari[sz]e|analy[sz]e|review|what is|what are|how does|why does)\b/i;
+}
+function fullToolSurfaceIntentPattern() {
+    return /(实现|修改|改成|改为|更新|写入|写一个|写个|创建|新建|生成|添加|新增|增加|删除|移除|删掉|修复|推进|执行|运行|验证|测试|编译|构建|提交)|\b(?:implement|edit|modify|update|write|create|generate|add|delete|remove|fix|repair|execute|run|verify|test|build|compile|commit)\b/i;
+}
+function shouldOfferMemoryForInput(input) {
+    return shouldOfferToolsForInput(input);
+}
+function shouldBufferSkillDecisionGuard(hasEnabledSkills, loadedSkillNames, prompted) {
+    return hasEnabledSkills && loadedSkillNames.size === 0 && !prompted;
+}
+function shouldRetrySkillDecisionGuard(hasEnabledSkills, loadedSkillNames, prompted, requestedToolCalls, modelTurns, maxTurns) {
+    return (hasEnabledSkills &&
+        loadedSkillNames.size === 0 &&
+        !prompted &&
+        modelTurns < maxTurns &&
+        requestedToolCalls.length > 0 &&
+        requestedToolCalls.every(toolCall => toolCall.name !== loadSkillToolName));
+}
+function buildSkillDecisionGuardPrompt(input, requestedToolCalls, language) {
+    const toolNames = [...new Set(requestedToolCalls.map(toolCall => toolCall.name))].join(', ');
+    return [
+        'Runtime guard: before using task tools, decide whether one of the available Remi Skills applies.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `You just requested tool(s): ${toolNames}. Those tool calls were not executed yet.`,
+        'Review the Remi Skills index already provided in the system context.',
+        'If a listed skill semantically matches the request or the next action, call load_skill with that skill name now, and do not call other tools in the same assistant turn.',
+        'If no listed skill matches or the match is ambiguous, do not call load_skill; repeat the appropriate original tool call(s) and continue.',
+        'The runtime will not choose a skill for you. Only claim a skill was used after load_skill succeeds.',
+    ].join('\n');
+}
+function isExplicitSkillInvocationPrompt(input) {
+    return /^Use the Remi skill `[^`]+` for this turn\.\nSkill source: .+\n/.test(input) && input.includes('\nSkill instructions:\n');
+}
+function planPromptMode(planMode, requirement) {
+    if (planMode) {
+        return 'manual';
+    }
+    return requirement ? 'required' : undefined;
+}
+function createPlanFirstGuardState(requirement) {
+    return {
+        ...(requirement ? { requirement } : {}),
+        satisfied: false,
+    };
+}
+function recordPlanFirstToolOutcome(state) {
+    if (state.requirement) {
+        state.satisfied = true;
+        return state.requirement.executeAfterPlan;
+    }
+    return false;
+}
+function shouldBufferPlanFirstText(state) {
+    return Boolean(state.requirement && (!state.satisfied || !state.requirement.executeAfterPlan));
+}
+function shouldRetryMissingPlanFirst(state, retries, modelTurns, maxTurns) {
+    return Boolean(state.requirement && !state.satisfied && retries < defaultPlanFirstGuardRetries && modelTurns < maxTurns);
+}
+function shouldFailMissingPlanFirst(state) {
+    return Boolean(state.requirement && !state.satisfied);
+}
+function buildPlanFirstGuardPrompt(input, state, language) {
+    return [
+        'Runtime guard: this task requires a visible plan before implementation.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Reason: ${state.requirement?.reason ?? 'multi-step or risky implementation request'}.`,
+        'Inspect with read-only tools only if needed, then call todo_write with the complete current checklist.',
+        'Do not edit files, create/delete files, run build/test commands, or claim implementation work is complete in this turn.',
+        state.requirement?.executeAfterPlan
+            ? 'After todo_write, continue implementing the original request with normal tools unless you are blocked or need clarification.'
+            : 'After todo_write, briefly ask the user to approve or refine the plan.',
+    ].join('\n');
+}
+function planFirstGuardFailureMessage(state) {
+    return `I couldn't start implementation because this task needs a visible plan first. Missing successful todo_write for: ${state.requirement?.reason ?? 'multi-step or risky implementation request'}.`;
+}
+function planFirstCompletionClaimIssue(text, state) {
+    if (!state.requirement) {
+        return undefined;
+    }
+    if (state.requirement.executeAfterPlan && state.satisfied) {
+        return undefined;
+    }
+    if (mutationCompletionClaimKind(text)) {
+        return 'implementation';
+    }
+    if (verificationSuccessClaimKind(text)) {
+        return 'verification';
+    }
+    return undefined;
+}
+function buildPlanFirstClaimGuardPrompt(input, draft, state, issue, language) {
+    const issueLabel = issue === 'implementation' ? 'implementation or filesystem changes' : 'verification, build, test, or execution success';
+    return [
+        'Runtime guard: this is a plan-first turn, so the final answer must not claim implementation evidence.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Plan-first reason: ${state.requirement?.reason ?? 'multi-step or risky implementation request'}.`,
+        `Blocked draft: ${compactText(draft, 800)}`,
+        `Unsupported claim: ${issueLabel}.`,
+        state.requirement?.executeAfterPlan
+            ? 'Revise the answer so it does not claim implementation evidence before actual tool results. Continue implementation when normal tools become available.'
+            : 'Revise the answer to say that the plan is ready and ask the user to approve or refine it.',
+    ].join('\n');
+}
+function buildPlanFirstContinuationPrompt(input, language) {
+    return [
+        'Runtime: the visible plan has been recorded.',
+        runtimeLanguageRequirement(language),
+        `Continue implementing the original user request now: ${input}`,
+        'Normal implementation tools are now available.',
+        'Do not ask for confirmation unless the plan revealed an ambiguity, destructive action, or permission blocker.',
+    ].join('\n');
+}
+function buildPlanExecutionApprovalPrompt(input, approval, language, retry = false) {
+    const planLines = approval?.items.length
+        ? approval.items.map((item, index) => `${index + 1}. [${item.status}] ${item.content}`)
+        : ['(No plan items were available in the recent transcript.)'];
+    return [
+        retry
+            ? 'Runtime guard: the user already approved the recent visible plan, but the last response did not start execution.'
+            : 'Runtime: the user has approved the recent visible plan for execution.',
+        runtimeLanguageRequirement(language),
+        `Current user approval: ${input}`,
+        'Execute the latest recorded plan now with normal tools.',
+        'Do not recreate the same plan, do not ask for approval again, and do not stop after todo_write unless a real blocker or destructive ambiguity appears.',
+        'Use todo_write only to update item status while executing.',
+        'Latest visible plan:',
+        ...planLines,
+    ].join('\n');
+}
+function shouldRetryPlanExecutionApproval(approval, draft, retries, modelTurns, maxTurns) {
+    if (!approval || retries >= defaultPlanFirstGuardRetries || modelTurns >= maxTurns) {
+        return false;
+    }
+    return asksForPlanApprovalAgain(draft);
+}
+function shouldRetryPostActionApprovalDraft(draft, mutationState, verificationState, retries, modelTurns, maxTurns) {
+    if (retries >= defaultPlanFirstGuardRetries || modelTurns >= maxTurns) {
+        return false;
+    }
+    return hasCurrentTurnActionEvidence(mutationState, verificationState) && asksToStartAfterApproval(draft);
+}
+function buildPostActionApprovalGuardPrompt(input, draft, mutationState, verificationState, language) {
+    return [
+        'Runtime guard: the current turn already has successful execution evidence, but the draft asks the user to confirm before starting.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Blocked draft: ${compactText(draft, 800)}`,
+        `Current evidence: ${formatCurrentTurnActionEvidence(mutationState, verificationState)}.`,
+        'Revise the final answer as a completed-work summary grounded in current-turn tool results.',
+        'Do not ask the user to confirm before starting work that already happened.',
+    ].join('\n');
+}
+function asksForPlanApprovalAgain(text) {
+    const normalized = normalizeIntentText(text);
+    if (normalized.length === 0) {
+        return true;
+    }
+    return /(批准后|确认后|同意后|允许后|如果.*批准|请.*批准|请.*确认|是否.*执行|要我.*执行|再执行|我再执行|开始改|开始执行|approve|approval|confirm|shall i|should i)/i.test(normalized);
+}
+function asksToStartAfterApproval(text) {
+    const normalized = normalizeIntentText(text);
+    if (normalized.length === 0) {
+        return false;
+    }
+    return /(确认后|批准后|同意后|允许后|等确认|如果.{0,12}确认|请.{0,12}确认).{0,32}(开始|执行|实现|修改|改|写|创建|删除|运行|验证|测试|做|弄|搞)|(开始|执行|实现|修改|改|写|创建|删除|运行|验证|测试|做|弄|搞).{0,32}(前|之前).{0,12}(确认|批准|同意)|\b(?:after|once|when)\b.{0,24}\b(?:confirm|approve|approval)\b.{0,32}\b(?:start|execute|implement|edit|modify|write|create|delete|run|verify|test)\b|\b(?:confirm|approve)\b.{0,32}\b(?:and|then|before)\b.{0,32}\b(?:start|execute|implement|edit|modify|write|create|delete|run|verify|test)\b/i.test(normalized);
+}
+function planFirstClaimGuardFailureMessage(issue) {
+    const label = issue === 'implementation' ? 'implementation completion' : 'verification success';
+    return `Assistant attempted to claim ${label} during a plan-first turn.`;
+}
+function isHiddenPlanFirstToolCall(call, state, activeToolRegistry) {
+    return Boolean(state.requirement && !state.satisfied && !activeToolRegistry.get(call.toolName));
+}
+function planFirstUnavailableToolOutcome(call) {
+    const reason = [
+        `Tool ${call.toolName} is not available during this plan-first phase.`,
+        'Use read-only inspection if needed, then call todo_write with the complete plan.',
+        'Do not edit files, delete files, or run build/test commands until the plan has been recorded.',
+    ].join(' ');
+    const decision = {
+        status: 'deny',
+        reason,
+        requirements: [],
+    };
+    const result = {
+        ok: false,
+        callId: call.id,
+        toolName: call.toolName,
+        error: {
+            code: 'PLAN_FIRST_TOOL_NOT_AVAILABLE',
+            message: reason,
+        },
+    };
+    return {
+        dryRun: false,
+        callId: call.id,
+        toolName: call.toolName,
+        permissionDecision: decision,
+        transcriptEvents: [],
+        result,
+    };
+}
+function createRepeatedToolCallState() {
+    return { counts: new Map() };
+}
+function maybeRepeatedToolCallOutcome(call, registry, state) {
+    if (isMutationLikeTool(call.toolName)) {
+        state.counts.clear();
+        return undefined;
+    }
+    const signature = stableToolCallSignature(call);
+    const count = (state.counts.get(signature) ?? 0) + 1;
+    state.counts.set(signature, count);
+    if (count <= maxIdenticalToolCallsBeforeSuppression) {
+        return undefined;
+    }
+    const reason = [
+        `Repeated identical ${call.toolName} call suppressed after ${count - 1} previous attempt(s).`,
+        'Use the previous tool result, or retry with a different path, query, glob, or command if new information is needed.',
+    ].join(' ');
+    const tool = registry.get(call.toolName);
+    const decision = {
+        status: 'deny',
+        reason,
+        requirements: tool?.permissionPolicy.requirements ?? [],
+    };
+    const result = {
+        ok: false,
+        callId: call.id,
+        toolName: call.toolName,
+        error: {
+            code: 'REPEATED_TOOL_CALL',
+            message: reason,
+        },
+    };
+    return {
+        dryRun: false,
+        callId: call.id,
+        toolName: call.toolName,
+        permissionDecision: decision,
+        transcriptEvents: [
+            ...(tool
+                ? [
+                    {
+                        type: 'tool_call',
+                        callId: call.id,
+                        toolName: call.toolName,
+                        input: call.input,
+                        riskLevel: tool.riskLevel,
+                        permissionPolicy: tool.permissionPolicy,
+                        status: 'denied',
+                    },
+                ]
+                : []),
+            {
+                type: 'tool_result',
+                callId: call.id,
+                toolName: call.toolName,
+                ok: false,
+                summary: reason,
+                errorCode: 'REPEATED_TOOL_CALL',
+            },
+        ],
+        result,
+    };
+}
+function isMutationLikeTool(toolName) {
+    return (toolName === 'create_directory' ||
+        toolName === 'edit_file' ||
+        toolName === 'write_file' ||
+        toolName === 'delete_file' ||
+        toolName === 'delete_directory' ||
+        toolName === 'execute_shell');
+}
+function stableToolCallSignature(call) {
+    return `${call.toolName}:${stableJsonStringify(call.input)}`;
+}
+function stableJsonStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(item => stableJsonStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map(key => `${JSON.stringify(key)}:${stableJsonStringify(record[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function planFirstRequirementForInput(input, events) {
+    const normalized = normalizeIntentText(input);
+    if (!shouldOfferToolsForInput(input) || normalized.length === 0) {
+        return undefined;
+    }
+    if (isPlanExecutionConsent(normalized) && hasRecentSuccessfulPlan(events)) {
+        return undefined;
+    }
+    if (simpleLowRiskRequestPattern().test(normalized)) {
+        return undefined;
+    }
+    if (isAdvisoryOnlyRequest(normalized)) {
+        return undefined;
+    }
+    if (explicitPlanningRequestPattern().test(normalized)) {
+        return { reason: 'the user asked for a plan or implementation approach', executeAfterPlan: false };
+    }
+    if (crossLanguageOrMigrationPattern().test(normalized)) {
+        return { reason: 'cross-language migration, rewrite, or broad refactor', executeAfterPlan: true };
+    }
+    if (newServicePattern().test(normalized)) {
+        return { reason: 'new service or API scaffolding spans multiple design choices', executeAfterPlan: true };
+    }
+    if (multiAlgorithmPattern().test(normalized)) {
+        return { reason: 'multi-algorithm or capability expansion is likely multi-step', executeAfterPlan: true };
+    }
+    if (broadProjectChangePattern().test(normalized)) {
+        return { reason: 'broad project-level implementation request', executeAfterPlan: true };
+    }
+    return undefined;
+}
+function planExecutionApprovalForInput(input, events) {
+    const normalized = normalizeIntentText(input);
+    if (!isPlanExecutionConsent(normalized)) {
+        return undefined;
+    }
+    const items = latestSuccessfulPlanItems(events);
+    return items ? { items } : undefined;
+}
+function normalizeIntentText(input) {
+    return input.trim().replace(/\s+/g, ' ').replace(/[。！？!?.,，、\s]+$/g, '').toLowerCase();
+}
+function resolveResponseLanguage(input) {
+    return /[\u3400-\u9fff]/.test(input) ? 'zh-Hans' : undefined;
+}
+function runtimeLanguageRequirement(language) {
+    if (language === 'zh-Hans') {
+        return 'Language requirement: user-facing prose, visible plan items, brief transition text, blockers, and final answer must be in Simplified Chinese. Do not use English filler or mixed-language lead-ins such as "Let me", "First", "I will", or "I need to"; write those clauses in Chinese instead. Keep code identifiers, file paths, commands, and tool JSON unchanged.';
+    }
+    if (language === 'en') {
+        return 'Language requirement: user-facing prose, visible plan items, brief transition text, blockers, and final answer must be in English. Keep code identifiers, file paths, commands, and tool JSON unchanged.';
+    }
+    return 'Language requirement: match the latest user message language for user-facing prose, visible plan items, brief transition text, blockers, and final answer. If the latest user message is Chinese, use Simplified Chinese and do not use English filler or mixed-language lead-ins such as "Let me", "First", "I will", or "I need to"; write those clauses in Chinese instead. Keep code identifiers, file paths, commands, and tool JSON unchanged.';
+}
+function isPlanExecutionConsent(normalized) {
+    return /(按计划|照计划|执行计划|开始执行|开始实现|继续执行|继续实现|可以执行|可以开始|执行吧|开始吧|实现吧|改吧|做吧|弄吧|搞吧|改|做|弄|搞|批准|同意|继续|可以|好|好的|行|开干|走起)|\b(?:ok|okay|yes|yep|proceed|continue|go ahead|approved|approve|start implementing|implement the plan|execute the plan)\b/i.test(normalized);
+}
+function hasRecentSuccessfulPlan(events) {
+    return Boolean(latestSuccessfulPlanItems(events));
+}
+function latestSuccessfulPlanItems(events) {
+    const successfulTodoCallIds = new Set(events
+        .filter((event) => event.type === 'tool_result' && event.toolName === 'todo_write' && event.ok)
+        .map(event => event.callId));
+    if (successfulTodoCallIds.size === 0) {
+        return undefined;
+    }
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'user') {
+            return undefined;
+        }
+        if (event?.type === 'system' && event.level === 'error' && isInterruptedSystemEvent(event)) {
+            return undefined;
+        }
+        if (event?.type === 'tool_call' && event.toolName === 'todo_write' && successfulTodoCallIds.has(event.callId)) {
+            return planItemsFromRawItems(event.input['items']);
+        }
+    }
+    return undefined;
+}
+function planItemsFromRawItems(rawItems) {
+    if (!Array.isArray(rawItems)) {
+        return undefined;
+    }
+    const items = [];
+    for (const rawItem of rawItems) {
+        if (!rawItem || typeof rawItem !== 'object' || Array.isArray(rawItem)) {
+            return undefined;
+        }
+        const record = rawItem;
+        const content = record['content'];
+        const status = record['status'];
+        const id = record['id'];
+        if (typeof content !== 'string' ||
+            (status !== 'pending' && status !== 'in_progress' && status !== 'completed') ||
+            (id !== undefined && typeof id !== 'string')) {
+            return undefined;
+        }
+        items.push({
+            ...(typeof id === 'string' ? { id } : {}),
+            content,
+            status,
+        });
+    }
+    return items;
+}
+function isInterruptedSystemEvent(event) {
+    return event.level === 'error' && /(interrupted by user|abort(?:ed)?)/i.test(event.content);
+}
+function simpleLowRiskRequestPattern() {
+    return /^(创建|新建|建立).{0,24}(空)?(目录|文件夹|folder|directory|dir)$|^(读|读取|查看|看看|列出|打开|搜索|查找).{0,80}$|\b(?:read|show|list|open|search|find)\b.{0,80}$/i;
+}
+function isAdvisoryOnlyRequest(normalized) {
+    if (!advisoryRequestPattern().test(normalized)) {
+        return false;
+    }
+    return !advisoryPlusActionPattern().test(normalized);
+}
+function isTextOnlyPlanRequest(normalized) {
+    if (!explicitPlanningRequestPattern().test(normalized)) {
+        return false;
+    }
+    if (textOnlyPlanActionPattern().test(normalized)) {
+        return false;
+    }
+    return textOnlyPlanQualifierPattern().test(normalized);
+}
+function advisoryRequestPattern() {
+    return /(推荐|建议|你觉得|应该|适合|优先|加什么|添加什么|新增什么|选什么|要不要|是否|可不可以|能不能)|\b(?:recommend|suggest|should|what should|which .* should|advice|what would .* add|which .* add)\b/i;
+}
+function advisoryPlusActionPattern() {
+    return /(并|然后|顺便|直接|现在|立刻).{0,16}(添加|新增|增加|实现|修改|创建|写入|删除)|\b(?:and|then|also|directly|now)\b.{0,24}\b(?:add|implement|create|write|edit|modify|delete)\b/i;
+}
+function explicitPlanningRequestPattern() {
+    return /(先)?(计划|规划|方案|设计方案|实施方案|执行方案|实现方案|技术方案)|\b(?:plan|planning|implementation plan|approach|design an approach)\b/i;
+}
+function textOnlyPlanQualifierPattern() {
+    return /(模拟|示例|样例|例子|假设|随便|看看|看一下|列一个|列出|简单输出|输出.{0,12}文字|只.{0,8}输出|仅.{0,8}输出|不用执行|不要执行|不执行|别执行)|\b(?:mock|sample|example|hypothetical|just show|only output|text only|do not execute|don't execute|no execution)\b/i;
+}
+function textOnlyPlanActionPattern() {
+    return /(然后|并|直接|现在|立刻).{0,24}(执行|实现|修改|改|写|创建|删除|运行|验证|测试)|\b(?:and|then|directly|now)\b.{0,32}\b(?:execute|implement|edit|modify|write|create|delete|run|verify|test)\b/i;
+}
+function crossLanguageOrMigrationPattern() {
+    return /(改成|改为|换成|转换成|迁移到|移植到|重写成|改造成).{0,36}(c\+\+|cpp|go|golang|rust|python|typescript|ts|javascript|js|java|语言|实现)|\b(?:convert|port|migrate|rewrite|refactor)\b.{0,48}\b(?:c\+\+|cpp|go|golang|rust|python|typescript|javascript|java|implementation)\b/i;
+}
+function newServicePattern() {
+    return /(创建|新建|新增|增加|实现|搭建).{0,36}(服务|后端|接口|api|微服务|service|backend|server|worker)|\b(?:create|build|implement|scaffold|add)\b.{0,48}\b(?:service|api|backend|server|worker)\b/i;
+}
+function multiAlgorithmPattern() {
+    return /(添加|新增|增加|补充|加入|实现|加|更多).{0,36}(算法|排序|查找|搜索|search|sort|sorting|algorithm)|(算法|排序|查找|搜索).{0,24}(更多|多个|一批|若干|相关|家族)|\b(?:add|implement)\b.{0,48}\b(?:algorithms?|sorts?|sorting|search)\b/i;
+}
+function broadProjectChangePattern() {
+    return /(重构|架构|大改|整体|整个|全量|端到端|系统性|拆分|模块化|改造).{0,60}(项目|工程|代码|实现|模块|目录|架构)?|\b(?:large-scale|project-wide|end-to-end|architecture|architectural|restructure|modularize)\b/i;
+}
+function requiredMutationToolsForInput(input, toolDefinitions) {
+    if (!shouldOfferToolsForInput(input)) {
+        return [];
+    }
+    if (isAdvisoryOnlyRequest(normalizeIntentText(input))) {
+        return [];
+    }
+    const availableTools = new Set(toolDefinitions.map(tool => tool.name));
+    if (availableTools.size === 0) {
+        return [];
+    }
+    const normalized = input.trim().toLowerCase();
+    const required = [];
+    const hasDeleteTerm = /(删除|移除|删掉|去掉)/.test(normalized) || /\b(delete|remove)\b/.test(normalized);
+    const hasContentRemovalContext = /(部分|片段|段落|段|代码|逻辑|函数|方法|内容|行|块|区块|章节|小节|注释|批注|备注|log|日志|section|part|snippet|block|code|logic|function|method|content|line|lines|comment|comments|logging)/.test(normalized);
+    const hasWriteMutationVerb = /(新建|新增|增加|创建|建立|生成|写入|写一个|写个|写|修改|改成|改为|换成|转换|迁移|更新|补上|补充|加入|添加|加|覆盖|重写)/.test(normalized) ||
+        /\b(create|write|edit|modify|update|add|append|insert|overwrite|replace|scaffold|generate|convert|port|migrate)\b/.test(normalized);
+    const hasDirectoryTerm = /(目录|文件夹|folder|directory|\bdir\b)/.test(normalized);
+    const hasWriteTerm = /(代码|逻辑|函数|方法|程序|项目|工程|文件(?!夹)|源码|实现|算法|排序|数据结构|包|模块|demo|示例|部分|片段|内容|行|块|log|日志|main\.|\.go|\.ts|\.tsx|\.js|\.jsx|\.py|\.md|c\+\+|cpp)/.test(normalized) ||
+        /\b(code|logic|function|method|program|project|file|source|package|module|comment|comments|implementation|algorithm|algorithms|sort|sorts|sorting|data structure|data structures|demo|example|app|cpp|c\+\+)\b/.test(normalized);
+    if (hasDeleteTerm && hasDirectoryTerm && !hasContentRemovalContext && availableTools.has('delete_directory')) {
+        required.push('delete_directory');
+    }
+    else if (hasDeleteTerm && !hasContentRemovalContext && availableTools.has('delete_file')) {
+        required.push('delete_file');
+    }
+    if (((hasWriteMutationVerb && hasWriteTerm) || (hasDeleteTerm && hasContentRemovalContext)) && (availableTools.has('edit_file') || availableTools.has('write_file'))) {
+        required.push('file_mutation');
+    }
+    if (hasWriteMutationVerb && hasDirectoryTerm && availableTools.has('create_directory')) {
+        required.push('create_directory');
+    }
+    return Array.from(new Set(required));
+}
+function createMutationGuardState(required, input) {
+    return {
+        required,
+        succeeded: new Set(),
+        noopSucceeded: new Set(),
+        failed: new Map(),
+        observedSucceeded: new Set(),
+        allowNoopDeletionEvidence: deletionMutationRequestPattern().test(input),
+    };
+}
+function shouldBufferMutationText(state) {
+    return state.required.length > 0 && !allRequiredMutationsSucceeded(state);
+}
+function shouldRetryMissingMutationTool(state, retries, modelTurns, maxTurns) {
+    return state.required.length > 0 && !allRequiredMutationsSucceeded(state) && retries < defaultMutationGuardRetries && modelTurns < maxTurns;
+}
+function shouldFailMissingMutationTool(state) {
+    return state.required.length > 0 && !allRequiredMutationsSucceeded(state);
+}
+function allRequiredMutationsSucceeded(state) {
+    return state.required.every(requirement => state.succeeded.has(requirement) || state.noopSucceeded.has(requirement));
+}
+function recordMutationToolOutcome(state, toolName, result, call) {
+    if (result.ok) {
+        const observed = mutationRequirementForTool(toolName);
+        if (observed) {
+            state.observedSucceeded.add(observed);
+        }
+    }
+    for (const requirement of state.required) {
+        if (!isMutationToolForRequirement(requirement, toolName)) {
+            continue;
+        }
+        if (result.ok) {
+            state.succeeded.add(requirement);
+            state.failed.delete(requirement);
+        }
+        else {
+            state.failed.set(requirement, `${result.error.code}: ${result.error.message}`);
+        }
+    }
+    recordShellRemovalMutationOutcome(state, toolName, result, call);
+    recordNoopDeletionEvidence(state, toolName, result);
+}
+function mutationRequirementForTool(toolName) {
+    if (toolName === 'edit_file' || toolName === 'write_file') {
+        return 'file_mutation';
+    }
+    if (toolName === 'create_directory') {
+        return 'create_directory';
+    }
+    if (toolName === 'delete_file') {
+        return 'delete_file';
+    }
+    if (toolName === 'delete_directory') {
+        return 'delete_directory';
+    }
+    return undefined;
+}
+function isMutationToolForRequirement(requiredMutationTool, toolName) {
+    if (requiredMutationTool === 'file_mutation') {
+        return toolName === 'edit_file' || toolName === 'write_file';
+    }
+    return toolName === requiredMutationTool;
+}
+function recordShellRemovalMutationOutcome(state, toolName, result, call) {
+    if (toolName !== 'execute_shell' || !result.ok || !shellCommandResultSucceeded(result)) {
+        return;
+    }
+    const command = typeof call?.input['command'] === 'string' ? call.input['command'] : '';
+    const removalCommand = shellRemovalCommand(command);
+    if (!removalCommand) {
+        return;
+    }
+    if (state.required.includes('file_mutation')) {
+        state.succeeded.add('file_mutation');
+        state.observedSucceeded.add('file_mutation');
+        state.failed.delete('file_mutation');
+    }
+    if (state.required.includes('delete_file') && removalCommand === 'rm') {
+        state.succeeded.add('delete_file');
+        state.observedSucceeded.add('delete_file');
+        state.failed.delete('delete_file');
+    }
+    if (state.required.includes('delete_directory')) {
+        state.succeeded.add('delete_directory');
+        state.observedSucceeded.add('delete_directory');
+        state.failed.delete('delete_directory');
+    }
+}
+function shellRemovalCommand(command) {
+    const trimmed = command.trim();
+    if (/^(?:command\s+)?rm(?:\s|$)/.test(trimmed) || /(?:^|[;&|]\s*)(?:command\s+)?rm(?:\s|$)/.test(trimmed)) {
+        return 'rm';
+    }
+    if (/^(?:command\s+)?rmdir(?:\s|$)/.test(trimmed) || /(?:^|[;&|]\s*)(?:command\s+)?rmdir(?:\s|$)/.test(trimmed)) {
+        return 'rmdir';
+    }
+    return undefined;
+}
+function recordNoopDeletionEvidence(state, toolName, result) {
+    if (!state.allowNoopDeletionEvidence ||
+        !state.required.includes('file_mutation') ||
+        !result.ok ||
+        (toolName !== 'glob' && toolName !== 'search_text')) {
+        return;
+    }
+    const parsed = parseToolOutput(result.output);
+    const matches = parsed?.['matches'];
+    if (!Array.isArray(matches) || matches.length !== 0 || parsed?.['truncated'] === true) {
+        return;
+    }
+    state.noopSucceeded.add('file_mutation');
+    state.failed.delete('file_mutation');
+}
+function shellCommandResultSucceeded(result) {
+    if (!result.ok) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(result.output);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return false;
+        }
+        return parsed['exitCode'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function requiredMutationToolLabel(requiredMutationTool) {
+    return requiredMutationTool === 'file_mutation' ? 'edit_file or write_file' : requiredMutationTool;
+}
+function buildMutationGuardPrompt(input, state, language) {
+    const missing = state.required.filter(requirement => !state.succeeded.has(requirement));
+    const toolInstructions = missing.map(requirement => {
+        if (requirement === 'file_mutation') {
+            return 'For file content changes, call read_file first, then edit_file for changes to an existing file. Use write_file for a new file or a full-file replacement only when that is the right operation.';
+        }
+        if (requirement === 'delete_file') {
+            return 'For user-requested file deletion, prefer delete_file. Shell rm is allowed only through execute_shell approval and must complete with exit 0 before you claim deletion.';
+        }
+        if (requirement === 'delete_directory') {
+            return 'For user-requested empty directory deletion, prefer delete_directory. Shell rmdir is allowed only through execute_shell approval and must complete with exit 0 before you claim deletion.';
+        }
+        return 'For requested directory creation, call create_directory.';
+    });
+    const failures = missing
+        .map(requirement => {
+        const failure = state.failed.get(requirement);
+        return failure ? `- ${requiredMutationToolLabel(requirement)} failed: ${failure}` : undefined;
+    })
+        .filter((line) => Boolean(line));
+    return [
+        'Runtime guard: the user asked for local filesystem changes, but not all required mutation tools succeeded.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Required successful mutations still missing: ${missing.map(requiredMutationToolLabel).join(', ')}`,
+        ...toolInstructions,
+        ...(failures.length > 0 ? ['Observed failed mutation attempts:', ...failures] : []),
+        'Do not claim completion until successful tool results for every required mutation are present in this turn.',
+        'If the tool is denied or the target cannot be safely changed, use the tool result to explain the actual blocker instead of saying the work is done.',
+    ].join('\n');
+}
+function mutationGuardFailureMessage(state) {
+    const missing = state.required.filter(requirement => !state.succeeded.has(requirement));
+    const labels = missing.map(userFacingMutationRequirementLabel).join(', ');
+    const failures = missing
+        .map(requirement => state.failed.get(requirement))
+        .filter((failure) => Boolean(failure));
+    const detail = failures.length > 0
+        ? ` Last tool failure: ${compactText(failures.at(-1) ?? '', 300)}`
+        : ' No successful filesystem change was recorded.';
+    return `I couldn't complete the requested filesystem change. Missing successful operation: ${labels}.${detail}`;
+}
+function shouldGuardMutationClaimsForInput(input, requiredMutationTools) {
+    if (requiredMutationTools.length > 0) {
+        return true;
+    }
+    if (isAdvisoryOnlyRequest(normalizeIntentText(input))) {
+        return false;
+    }
+    return mutationRequestPattern().test(input);
+}
+function mutationCompletionClaimIssue(text, state) {
+    const claim = mutationCompletionClaimKind(text);
+    if (!claim) {
+        return undefined;
+    }
+    if (claim === 'delete_file') {
+        return state.observedSucceeded.has('delete_file') || state.observedSucceeded.has('delete_directory') ? undefined : claim;
+    }
+    return state.observedSucceeded.has(claim) ? undefined : claim;
+}
+function mutationCompletionClaimKind(text) {
+    const normalized = text.replace(/\s+/g, ' ').trim().toLowerCase();
+    if (normalized.length === 0 || mutationClaimNegationPattern().test(normalized)) {
+        return undefined;
+    }
+    if (contentRemovalCompletionClaimPattern().test(normalized)) {
+        return 'file_mutation';
+    }
+    if (fileMutationCompletionClaimPattern().test(normalized)) {
+        return 'file_mutation';
+    }
+    if (directoryCreationCompletionClaimPattern().test(normalized)) {
+        return 'create_directory';
+    }
+    if (deleteCompletionClaimPattern().test(normalized)) {
+        return 'delete_file';
+    }
+    return undefined;
+}
+function buildMutationClaimGuardPrompt(input, draft, state, claim, language) {
+    const observed = state.observedSucceeded.size > 0 ? Array.from(state.observedSucceeded).map(requiredMutationToolLabel).join(', ') : 'none';
+    return [
+        'Runtime guard: your last draft claimed that a filesystem change was completed, but current-turn tool evidence does not support that claim.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Blocked draft: ${compactText(draft, 800)}`,
+        `Claim requires current-turn evidence for: ${requiredMutationToolLabel(claim)}`,
+        `Current successful mutation evidence: ${observed}`,
+        'Use current filesystem tools as the source of truth. Prior assistant messages and prior tool results are not proof of the current filesystem state.',
+        'If the user asked for a file change, read the current file and then call edit_file or write_file before claiming completion.',
+        'If no change can be made, revise the answer to explain the actual blocker instead of saying the work is done.',
+    ].join('\n');
+}
+function mutationClaimGuardFailureMessage(claim) {
+    return `I couldn't complete the requested filesystem change. The draft claimed completion, but no current-turn ${userFacingMutationRequirementLabel(claim)} succeeded.`;
+}
+function userFacingMutationRequirementLabel(requiredMutationTool) {
+    if (requiredMutationTool === 'file_mutation') {
+        return 'file edit or write';
+    }
+    if (requiredMutationTool === 'create_directory') {
+        return 'directory creation';
+    }
+    if (requiredMutationTool === 'delete_file') {
+        return 'file deletion';
+    }
+    return 'empty directory deletion';
+}
+function mutationRequestPattern() {
+    return /(新建|新增|增加|创建|建立|生成|写入|写一个|写个|写|修改|改成|改为|换成|转换|迁移|更新|补上|补充|加入|添加|加|覆盖|重写|删除|移除|删掉|去掉)|\b(create|write|edit|modify|update|add|append|insert|overwrite|replace|scaffold|generate|convert|port|migrate|delete|remove)\b/i;
+}
+function deletionMutationRequestPattern() {
+    return /(删除|移除|删掉|去掉)|\b(?:delete|remove)\b/i;
+}
+function mutationClaimNegationPattern() {
+    return /(没有|未|无法|不能|尚未|无需|不需要|不必|不建议).{0,16}(新增|添加|写入|更新|修改|创建|删除|验证|运行)|\b(?:did not|didn't|not|cannot|can't|unable to|no need to|do not need to|don't need to|should not)\b.{0,32}\b(?:add|write|update|modify|create|delete|verify|run|remove)\b/i;
+}
+function contentRemovalCompletionClaimPattern() {
+    return /(已|已经|成功)?(删除|移除|删掉|去掉).{0,28}(部分|片段|段落|段|代码|逻辑|函数|方法|内容|行|块|区块|章节|小节|注释|批注|备注|log|日志|调用|section|part|snippet|block|code|logic|function|method|content|line|lines|comment|comments|logging|call)|(部分|片段|代码|内容|注释|log|日志|调用).{0,28}(删除|移除|删掉|去掉)(了|完成|成功)?/i;
+}
+function fileMutationCompletionClaimPattern() {
+    return /(搞定|完成).{0,80}(新增|添加|写入|更新|修改|改好|实现|补上|加入|重写|替换|迁移|排序|算法)|(已|已经).{0,16}(新增|添加|写入|更新|修改|改成|实现|补上|加入|重写|替换|迁移)|(新增|添加|写入|更新|修改|实现|补上|加入|重写|替换|迁移)(了|完成|好了|成功)|\b(?:added|updated|modified|wrote|implemented|replaced|migrated)\b/i;
+}
+function directoryCreationCompletionClaimPattern() {
+    return /(已|已经|成功)?(创建|新建|建立).{0,20}(目录|文件夹)|(目录|文件夹).{0,20}(创建|新建|建立)(了|完成|成功)?|\bcreated\b.{0,24}\b(?:directory|folder|dir)\b/i;
+}
+function deleteCompletionClaimPattern() {
+    return /(已|已经|成功)(删除|移除|删掉|去掉)(了|完成|成功)?|(删除|移除|删掉|去掉)(了|完成|成功)|\b(?:deleted|removed)\b/i;
+}
+function createVerificationGuardState() {
+    return {};
+}
+function shouldGuardVerificationClaimsForInput(input, requiredMutationTools) {
+    if (requiredMutationTools.length > 0) {
+        return true;
+    }
+    return verificationRequestPattern().test(input);
+}
+function recordVerificationToolOutcome(state, toolName, result) {
+    if (toolName !== 'execute_shell' && toolName !== 'run_command') {
+        return;
+    }
+    if (!result.ok) {
+        state.lastShell = {
+            status: 'failed',
+            command: toolName,
+            detail: `${result.error.code}: ${result.error.message}`,
+        };
+        return;
+    }
+    const parsed = parseToolOutput(result.output);
+    const command = typeof parsed?.['command'] === 'string' ? parsed['command'] : toolName;
+    const exitCode = typeof parsed?.['exitCode'] === 'number' ? parsed['exitCode'] : undefined;
+    const timedOut = parsed?.['timedOut'] === true;
+    const status = exitCode === 0 && !timedOut ? 'success' : 'failed';
+    const detail = exitCode === undefined
+        ? 'exit code unavailable'
+        : timedOut
+            ? `timed out after exit ${exitCode}`
+            : `exit ${exitCode}`;
+    const evidence = { status, command, detail };
+    state.lastShell = evidence;
+    if (isVerificationCommand(command)) {
+        state.lastVerification = evidence;
+    }
+}
+function hasCurrentTurnActionEvidence(mutationState, verificationState) {
+    return (mutationState.observedSucceeded.size > 0 ||
+        verificationState.lastShell?.status === 'success' ||
+        verificationState.lastVerification?.status === 'success');
+}
+function formatCurrentTurnActionEvidence(mutationState, verificationState) {
+    const evidence = [];
+    if (mutationState.observedSucceeded.size > 0) {
+        evidence.push(`successful mutation tools: ${Array.from(mutationState.observedSucceeded).map(requiredMutationToolLabel).join(', ')}`);
+    }
+    if (verificationState.lastVerification?.status === 'success') {
+        evidence.push(`successful verification: ${verificationState.lastVerification.command} (${verificationState.lastVerification.detail})`);
+    }
+    else if (verificationState.lastShell?.status === 'success') {
+        evidence.push(`successful command: ${verificationState.lastShell.command} (${verificationState.lastShell.detail})`);
+    }
+    return evidence.length > 0 ? evidence.join('; ') : 'none';
+}
+function verificationClaimGuardIssue(text, state) {
+    const claimKind = verificationSuccessClaimKind(text);
+    if (!claimKind) {
+        return undefined;
+    }
+    const evidence = claimKind === 'verification' ? state.lastVerification : state.lastShell ?? state.lastVerification;
+    return evidence?.status === 'success' ? undefined : claimKind;
+}
+function verificationSuccessClaimKind(text) {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    if (normalized.length === 0 || verificationNegationPattern().test(normalized)) {
+        return undefined;
+    }
+    if (verificationSuccessPattern().test(normalized)) {
+        return 'verification';
+    }
+    return executionSuccessPattern().test(normalized) ? 'execution' : undefined;
+}
+function buildVerificationClaimGuardPrompt(input, draft, state, language) {
+    const evidence = formatVerificationEvidence(state);
+    return [
+        'Runtime guard: your last draft claimed that verification, compilation, tests, or execution succeeded, but current-turn tool evidence does not support that claim.',
+        runtimeLanguageRequirement(language),
+        `Original user request: ${input}`,
+        `Blocked draft: ${compactText(draft, 800)}`,
+        `Current evidence: ${evidence}`,
+        'Revise the final answer so it is strictly grounded in successful current-turn tool results.',
+        'Do not say build/test/run/verification passed unless a successful current-turn execute_shell or run_command result proves it.',
+        'If files were changed but validation did not run, was denied, or failed, say that directly and include the exact manual command when it is known.',
+    ].join('\n');
+}
+function verificationClaimGuardFailureMessage(state) {
+    return `Assistant attempted to claim verification success without successful current-turn evidence. ${formatVerificationEvidence(state)}`;
+}
+function formatVerificationEvidence(state) {
+    const evidence = state.lastVerification ?? state.lastShell;
+    if (!evidence) {
+        return 'no validation command has succeeded in this turn.';
+    }
+    return `last command ${evidence.status}: ${evidence.command} (${evidence.detail}).`;
+}
+function verificationRequestPattern() {
+    return /(测试|验证|编译|构建|运行|跑一下|执行)|\b(test|verify|validate|compile|build|run|execute)\b/i;
+}
+function verificationSuccessPattern() {
+    return /(测试|验证|编译|构建).{0,24}(通过|成功|正常)|(?:通过|成功).{0,24}(测试|验证|编译|构建)|\b(?:tests?|test suite|build|compile|compilation|validation|verification)\b.{0,48}\b(?:pass(?:ed|es)?|succeed(?:ed)?|successful(?:ly)?|green|ok)\b|\b(?:all|everything)\b.{0,32}\b(?:pass(?:ed)?|succeed(?:ed)?|successful)\b/i;
+}
+function executionSuccessPattern() {
+    return /(运行|执行).{0,24}(通过|成功|正常)|(?:正常运行|运行正常|全部正常运行)|\b(?:command|run|ran|execution)\b.{0,48}\b(?:pass(?:ed)?|succeed(?:ed)?|successful(?:ly)?|ok)\b/i;
+}
+function verificationNegationPattern() {
+    return /(未|没|没有|无法|不能|未能|尚未).{0,24}(测试|验证|编译|构建|运行|执行|通过|成功)|手动运行|需要.{0,12}运行|自行.{0,12}运行|\b(?:not|never)\s+(?:run|ran|verified|tested|built|compiled)|\b(?:could not|unable to|manual|not verified|not run|did not run)\b/i;
+}
+function isVerificationCommand(command) {
+    const normalized = command.trim().toLowerCase();
+    return /(^|[;&]\s*)(go\s+(test|run|vet|build)|cargo\s+(test|build|run)|pnpm\s+(test|build|run\s+\S+)|npm\s+(test|run\s+\S+)|yarn\s+(test|build|run\s+\S+)|bun\s+(test|run|build)|python3?\s+-m\s+(pytest|unittest|mypy|ruff)|pytest|vitest|tsc|make|cmake|gcc|g\+\+|clang|clang\+\+|javac|mvn\s+test|gradle\s+test|swift\s+test|xcodebuild|node\s+\S+|\.\/\S*test\S*)(\s|$)/.test(normalized);
+}
+function toolDefinitionsForProvider(registry, extraTools = []) {
+    return [
+        ...extraTools,
+        ...registry.list().map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+        })),
+    ];
+}
+function skillToolDefinitionsForProvider(index) {
+    return index.skills.some(skill => skill.enabled)
+        ? [
+            {
+                name: loadSkillTool.name,
+                description: loadSkillTool.description,
+                parameters: loadSkillTool.inputSchema,
+            },
+        ]
+        : [];
+}
+function loadSkillToolCallOutcome(toolCall, options) {
+    const parsed = parseToolArguments(toolCall.arguments, loadSkillTool);
+    if (!parsed.ok) {
+        return {
+            result: {
+                ok: false,
+                callId: toolCall.id,
+                toolName: loadSkillToolName,
+                error: {
+                    code: 'TOOL_ARGUMENTS_INVALID',
+                    message: parsed.result.message,
+                },
+            },
+        };
+    }
+    const skillName = parsed.input['name'];
+    if (typeof skillName !== 'string' || skillName.trim().length === 0) {
+        return {
+            result: {
+                ok: false,
+                callId: toolCall.id,
+                toolName: loadSkillToolName,
+                error: {
+                    code: 'TOOL_ARGUMENTS_INVALID',
+                    message: 'Tool arguments are missing required field(s): name.',
+                },
+            },
+        };
+    }
+    const skill = loadSkillContent({
+        ...options,
+        name: skillName,
+        maxContentChars: maxLoadedSkillContentChars,
+    });
+    if (!skill) {
+        return {
+            result: {
+                ok: false,
+                callId: toolCall.id,
+                toolName: loadSkillToolName,
+                error: {
+                    code: 'SKILL_NOT_FOUND',
+                    message: `Skill ${skillName} is not available in the current Remi skill index.`,
+                },
+            },
+        };
+    }
+    const output = JSON.stringify({
+        ok: true,
+        skill: {
+            name: skill.name,
+            displayName: skill.displayName,
+            source: skill.source,
+            filePath: skill.filePath,
+            instructions: skill.content,
+        },
+        guidance: 'Apply these skill instructions for the rest of this turn before producing the user-facing answer.',
+    });
+    return {
+        skill,
+        result: {
+            ok: true,
+            callId: toolCall.id,
+            toolName: loadSkillToolName,
+            output,
+            truncated: false,
+            bytes: Buffer.byteLength(output, 'utf8'),
+        },
+    };
+}
+function normalizeSkillNameForRuntime(name) {
+    return name.trim().toLowerCase();
+}
+function buildToolUseSystemPrompt(cwd, env, planMode = undefined, language) {
+    const base = readToolUseSystemPromptTemplate()
+        .replaceAll('{{cwd}}', cwd)
+        .replaceAll('{{home_line}}', env.HOME ? `User home directory: ${env.HOME}` : '')
+        .replaceAll('{{host_platform}}', hostPlatformForPrompt());
+    const languageBlock = `Response language:\n- ${runtimeLanguageRequirement(language)}`;
+    const baseWithLanguage = `${base}\n\n${languageBlock}`;
+    if (!planMode) {
+        return baseWithLanguage;
+    }
+    const heading = planMode === 'required' ? 'Plan-first is required for this turn:' : 'Plan mode is active:';
+    const approvalLine = planMode === 'required'
+        ? '- After todo_write, continue implementing the original request when normal tools become available; ask the user only if the plan reveals ambiguity, destructive risk, or a permission blocker.'
+        : '- Ask the user to approve or refine the plan before execution.';
+    return `${baseWithLanguage}
+
+${heading}
+- Do not edit files, create/delete files, or run build/test/execute commands in this turn.
+- Inspect with read-only tools when needed, then use todo_write to produce or update the plan.
+${approvalLine}`;
+}
+let cachedToolUseSystemPromptTemplate;
+function readToolUseSystemPromptTemplate() {
+    if (cachedToolUseSystemPromptTemplate !== undefined) {
+        return cachedToolUseSystemPromptTemplate;
+    }
+    try {
+        cachedToolUseSystemPromptTemplate = readFileSync(new URL('../../../prompt/tool-use-system.md', import.meta.url), 'utf8').trim();
+    }
+    catch {
+        cachedToolUseSystemPromptTemplate = [
+            'You can use Remi local tools for read-only project inspection.',
+            'Current working directory: {{cwd}}',
+            '{{home_line}}',
+            'Host platform: {{host_platform}}',
+            'Prefer structured filesystem tools over shell commands.',
+            'For broad directory overviews, inspect one useful next layer and summarize meaning.',
+            'If you do not know an exact file path, discover it with list_files or glob before calling read_file.',
+            'Use create_directory, edit_file, and write_file when the user asks you to change local files.',
+            'Use delete_file when the user explicitly asks to remove a file; prefer it over shell rm. For multiple files, call delete_file once per file.',
+            'Use delete_directory when the user explicitly asks to remove an empty directory; prefer it over shell rmdir. For multiple empty directories, call delete_directory once per directory.',
+            'Read existing files before editing or overwriting them.',
+            'Prior assistant messages are conversation history, not proof of the current filesystem state.',
+            'Use `run_command` only for simple read-only local inspection commands when structured tools are insufficient.',
+            'Treat common host tasks as command capabilities: network.ip, network.mac, network.ports, download.url, logs.search, and tool.install.',
+            'Prefer host-platform query commands. For IP use ifconfig/ip on macOS/Linux and ipconfig on Windows. For MAC use ifconfig/ip link/getmac. For ports use lsof/netstat/ss on macOS/Linux and netstat on Windows.',
+            'If a read-only command returns exit code 127 or says Command not found, try a platform-equivalent allowlisted command before concluding failure.',
+            'Allowed `run_command` executables include safe read-only local inspection commands such as `grep`, `find`, `ps`, `wc`, `file`, `stat`, `du`, `df`, `sort`, `diff`, `strings`, `ifconfig`, `ip`, `ipconfig`, `getmac`, `netstat`, `ss`, `lsof`, and read-only `git` subcommands.',
+            'Do not call `run_command` for `cd`, `go`, `go run`, `go test`, `go mod`, package managers, interpreters, build/test commands, write commands, curl/wget downloads, or chained shell commands.',
+            'Use `execute_shell` for build/test/verification commands, package manager installs, network downloads, and side-effect commands such as `sed`, `cp`, `mv`, `rm`, `rmdir`, `sh`, `curl`, `wget`, `brew`, `apt`, `apt-get`, `winget`, `choco`, `scoop`, or project scripts after file work is ready. Pass its `cwd` argument when the command must run from a package directory; single-line `cd <dir> && command` is also supported when needed. The runtime will request approval when needed. Do not add sudo; admin-risk installs need a separate explicit approval path.',
+            'The current working directory is Remi runtime cwd, not always the target project. If Recent Filesystem Locations are present, resolve repeated project names to those absolute paths instead of creating same-named directories under cwd.',
+            'For nested projects, inspect the directory tree before reading conventional filenames; those files may live under subdirectories.',
+            'For simple project scaffolding, create the directory and minimal source/config files directly when the file contents are straightforward.',
+            'If a command is denied but files can still be written, write the files and tell the user which command to run manually.',
+            'If a denied command was an rm or rmdir deletion attempt, do not retry with a broader shell form. Use delete_file or delete_directory when that can express the requested target, or explain the safety blocker.',
+            'Never read secrets or local credentials.',
+            'After using tools, produce a user-facing answer.',
+        ].join('\n');
+    }
+    return cachedToolUseSystemPromptTemplate;
+}
+function hostPlatformForPrompt() {
+    if (process.platform === 'darwin') {
+        return 'macOS (darwin)';
+    }
+    if (process.platform === 'linux') {
+        return 'Linux (linux)';
+    }
+    if (process.platform === 'win32') {
+        return 'Windows (win32)';
+    }
+    return `${process.platform}`;
+}
+function toolCallFromLLM(toolCall, registry) {
+    const tool = registry.get(toolCall.name);
+    const parsed = parseToolArguments(toolCall.arguments, tool);
+    if (!parsed.ok) {
+        return parsed;
+    }
+    return {
+        ok: true,
+        call: {
+            id: toolCall.id,
+            toolName: toolCall.name,
+            input: parsed.input,
+        },
+    };
+}
+function parseToolArguments(rawArguments, tool) {
+    if (rawArguments.trim().length === 0) {
+        const input = {};
+        const validation = validateToolArguments(input, tool?.inputSchema);
+        return validation.ok
+            ? { ok: true, input }
+            : {
+                ok: false,
+                result: {
+                    code: 'TOOL_ARGUMENTS_INVALID',
+                    message: validation.message,
+                    rawArguments,
+                    repairedArguments: input,
+                },
+            };
+    }
+    const parsed = parseToolArgumentsJson(rawArguments, tool?.inputSchema);
+    if (!parsed.ok) {
+        return parsed;
+    }
+    const validation = validateToolArguments(parsed.input, tool?.inputSchema);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            result: {
+                code: 'TOOL_ARGUMENTS_INVALID',
+                message: validation.message,
+                rawArguments,
+                ...(parsed.repaired ? { repairedArguments: parsed.input } : {}),
+            },
+        };
+    }
+    return { ok: true, input: parsed.input };
+}
+function parseToolArgumentsJson(rawArguments, schema) {
+    const raw = rawArguments.trim();
+    try {
+        return { ok: true, input: normalizeParsedToolArguments(JSON.parse(raw)), repaired: false };
+    }
+    catch (error) {
+        const repairedRaw = repairToolArgumentsJson(raw, schema);
+        if (repairedRaw && repairedRaw !== raw) {
+            try {
+                return { ok: true, input: normalizeParsedToolArguments(JSON.parse(repairedRaw)), repaired: true };
+            }
+            catch {
+                // Fall through to the structured recovery pass below.
+            }
+        }
+        const recovered = recoverToolArgumentsObject(raw, schema);
+        if (recovered && Object.keys(recovered).length > 0) {
+            return { ok: true, input: recovered, repaired: true };
+        }
+        return {
+            ok: false,
+            result: {
+                code: 'TOOL_ARGUMENTS_INVALID',
+                message: `Tool arguments must be a valid JSON object. ${safeJsonParseError(error)}`,
+                rawArguments,
+            },
+        };
+    }
+}
+function normalizeParsedToolArguments(parsed) {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Tool arguments must be a JSON object');
+    }
+    return parsed;
+}
+function repairToolArgumentsJson(raw, schema) {
+    if (!schema) {
+        return undefined;
+    }
+    return raw.replace(/("[^"]+"\s*:\s*)([^",{}\[\]\r\n][^,}\]\r\n]*)/g, (match, prefix, value) => {
+        const keyMatch = /"([^"]+)"\s*:\s*$/.exec(prefix);
+        const key = keyMatch?.[1];
+        const property = key ? schema.properties[key] : undefined;
+        const trimmed = value.trim();
+        if (!property || property.type !== 'string' || isJsonLiteralLike(trimmed)) {
+            return match;
+        }
+        return `${prefix}${JSON.stringify(trimmed)}`;
+    });
+}
+function recoverToolArgumentsObject(raw, schema) {
+    if (!schema) {
+        return undefined;
+    }
+    const recovered = {};
+    for (const [key, property] of Object.entries(schema.properties)) {
+        const rawValue = recoverRawObjectPropertyValue(raw, key);
+        if (rawValue === undefined) {
+            continue;
+        }
+        const value = recoverToolArgumentValue(rawValue, property);
+        if (value !== undefined) {
+            recovered[key] = value;
+        }
+    }
+    return Object.keys(recovered).length > 0 ? recovered : undefined;
+}
+function recoverRawObjectPropertyValue(raw, key) {
+    const keyMatch = new RegExp(`(?:"${escapeRegExp(key)}"|${escapeRegExp(key)})\\s*:\\s*`).exec(raw);
+    if (!keyMatch) {
+        return undefined;
+    }
+    const start = keyMatch.index + keyMatch[0].length;
+    let depth = 0;
+    let quote;
+    for (let index = start; index < raw.length; index += 1) {
+        const char = raw[index];
+        const previous = index > start ? raw[index - 1] : undefined;
+        if (quote) {
+            if (char === quote && previous !== '\\') {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '{' || char === '[') {
+            depth += 1;
+            continue;
+        }
+        if (char === '}' || char === ']') {
+            if (depth === 0) {
+                return raw.slice(start, index).trim();
+            }
+            depth -= 1;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            return raw.slice(start, index).trim();
+        }
+    }
+    return raw.slice(start).trim();
+}
+function recoverToolArgumentValue(rawValue, property) {
+    const trimmed = rawValue.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return validateToolArgumentType(parsed, property) ? parsed : undefined;
+    }
+    catch {
+        if (property.type === 'string') {
+            return stripLooseQuotes(trimmed);
+        }
+        if (property.type === 'boolean') {
+            return trimmed === 'true' ? true : trimmed === 'false' ? false : undefined;
+        }
+        if (property.type === 'integer') {
+            return /^-?\d+$/.test(trimmed) ? Number(trimmed) : undefined;
+        }
+        if (property.type === 'number') {
+            return /^-?\d+(?:\.\d+)?$/.test(trimmed) ? Number(trimmed) : undefined;
+        }
+    }
+    return undefined;
+}
+function stripLooseQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function validateToolArguments(input, schema) {
+    if (!schema) {
+        return { ok: true };
+    }
+    const missing = (schema.required ?? []).filter(key => input[key] === undefined || input[key] === null);
+    if (missing.length > 0) {
+        return { ok: false, message: `Tool arguments are missing required field(s): ${missing.join(', ')}.` };
+    }
+    const invalid = [];
+    for (const [key, value] of Object.entries(input)) {
+        const property = schema.properties[key];
+        if (!property) {
+            if (schema.additionalProperties === false) {
+                delete input[key];
+            }
+            continue;
+        }
+        if (!validateToolArgumentType(value, property)) {
+            invalid.push(`${key} must be ${property.type}`);
+        }
+    }
+    return invalid.length > 0 ? { ok: false, message: `Tool arguments have invalid field type(s): ${invalid.join(', ')}.` } : { ok: true };
+}
+function validateToolArgumentType(value, property) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    if (property.type === 'array') {
+        return Array.isArray(value);
+    }
+    if (property.type === 'object') {
+        return typeof value === 'object' && !Array.isArray(value);
+    }
+    if (property.type === 'integer') {
+        return typeof value === 'number' && Number.isInteger(value);
+    }
+    if (property.type === 'number') {
+        return typeof value === 'number' && Number.isFinite(value);
+    }
+    return typeof value === property.type;
+}
+function isJsonLiteralLike(value) {
+    return value === 'true' || value === 'false' || value === 'null' || /^-?\d+(?:\.\d+)?$/.test(value);
+}
+function safeJsonParseError(error) {
+    return error instanceof Error ? error.message.replace(/ at position \d+.*/, '') : String(error);
+}
+function invalidToolArgumentsOutcome(toolCall, failure) {
+    const decision = {
+        status: 'deny',
+        reason: 'Tool arguments need to be retried with valid JSON.',
+        requirements: [],
+    };
+    const result = {
+        ok: false,
+        callId: toolCall.id,
+        toolName: toolCall.name,
+        error: {
+            code: failure.code,
+            message: failure.message,
+        },
+    };
+    return {
+        dryRun: false,
+        callId: toolCall.id,
+        toolName: toolCall.name,
+        permissionDecision: decision,
+        transcriptEvents: [
+            {
+                type: 'tool_result',
+                callId: toolCall.id,
+                toolName: toolCall.name,
+                ok: false,
+                summary: failure.message,
+                errorCode: failure.code,
+            },
+        ],
+        result,
+    };
+}
+function summarizeInvalidToolArgumentsCall(toolCall) {
+    return `invalid arguments for ${toolCall.name}`;
+}
+function toolArgumentFailureMessage(retries, failure) {
+    const hint = failure.repairedArguments
+        ? ` Recovered fields were: ${Object.keys(failure.repairedArguments).join(', ')}.`
+        : '';
+    return `The model kept sending invalid tool arguments after ${retries} repair attempt(s).${hint} Please retry the request so Remi can ask the model to issue valid tool JSON.`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function summarizeToolCall(call) {
+    const path = typeof call.input['path'] === 'string' ? call.input['path'] : undefined;
+    const query = typeof call.input['query'] === 'string' ? call.input['query'] : undefined;
+    const pattern = typeof call.input['pattern'] === 'string' ? call.input['pattern'] : undefined;
+    const command = typeof call.input['command'] === 'string' ? call.input['command'] : undefined;
+    const includeGlob = typeof call.input['includeGlob'] === 'string' ? call.input['includeGlob'] : undefined;
+    if (call.toolName === 'search_text' && query) {
+        return formatSearchToolCallSummary(query, path, includeGlob);
+    }
+    if (call.toolName === 'glob' && pattern) {
+        return pattern;
+    }
+    if (call.toolName === 'todo_write') {
+        return 'plan update';
+    }
+    const target = command ?? path ?? pattern ?? query;
+    return target ? target : JSON.stringify(call.input);
+}
+function formatSearchToolCallSummary(query, path, includeGlob) {
+    const scope = path && path !== '.' ? ` in ${path}` : '';
+    const include = includeGlob ? ` matching ${includeGlob}` : '';
+    return `${query}${scope}${include}`;
+}
+function summarizeToolResult(result) {
+    if (!result.ok) {
+        return summarizeToolError(result);
+    }
+    return summarizeToolOutput(result.output, result.truncated);
+}
+function summarizeToolError(result) {
+    const message = compactText(result.error.message, 200);
+    if (result.error.code === 'COMMAND_DENIED') {
+        return message ? `Command could not run: ${message}` : 'Command could not run.';
+    }
+    if (result.error.code === 'PERMISSION_REQUIRED') {
+        return message ? `Permission required: ${message}` : 'Permission required.';
+    }
+    if (result.error.code === 'PERMISSION_DENIED') {
+        return message ? `Permission was not granted: ${message}` : 'Permission was not granted.';
+    }
+    if (result.error.code === 'UNKNOWN_TOOL' || result.error.code === 'PLAN_FIRST_TOOL_NOT_AVAILABLE') {
+        return message ? `Tool is not available: ${message}` : 'Tool is not available.';
+    }
+    if (result.error.code === 'REPEATED_TOOL_CALL') {
+        return message ? `Repeated tool call skipped: ${message}` : 'Repeated tool call skipped.';
+    }
+    return message ? `Tool failed: ${message}` : 'Tool failed.';
+}
+function summarizeToolOutput(output, truncated) {
+    const parsed = parseToolOutput(output);
+    const summary = parsed ? summarizeParsedToolOutput(parsed) : compactText(output, 240);
+    return truncated ? `${summary} [truncated]` : summary;
+}
+function summarizeToolDetail(result) {
+    if (!result.ok) {
+        return undefined;
+    }
+    const parsed = parseToolOutput(result.output);
+    if (!parsed) {
+        return undefined;
+    }
+    if (typeof parsed['diffPreview'] === 'string') {
+        const diffPreview = parsed['diffPreview'].trim();
+        return diffPreview.length > 0 ? diffPreview : undefined;
+    }
+    if (typeof parsed['command'] === 'string' && typeof parsed['stdout'] === 'string') {
+        const stdout = parsed['stdout'];
+        const stderr = typeof parsed['stderr'] === 'string' ? parsed['stderr'] : '';
+        return compactMultilineOutput(joinCommandOutput(stdout, stderr), 8_000);
+    }
+    return undefined;
+}
+function isRecoverableToolProtocolError(result) {
+    if (result.ok) {
+        return false;
+    }
+    if ((result.toolName === 'run_command' || result.toolName === 'execute_shell') && result.error.code === 'COMMAND_DENIED') {
+        return true;
+    }
+    if (result.error.code === 'UNKNOWN_TOOL') {
+        return true;
+    }
+    if (result.error.code === 'TOOL_ARGUMENTS_INVALID') {
+        return true;
+    }
+    if (result.error.code === 'REPEATED_TOOL_CALL') {
+        return true;
+    }
+    if ((result.toolName === 'edit_file' || result.toolName === 'write_file') && recoverableWriteToolProtocolErrors.has(result.error.code)) {
+        return true;
+    }
+    return ((result.toolName === 'read_file' || result.toolName === 'list_files' || result.toolName === 'search_text' || result.toolName === 'glob') &&
+        recoverableExplorationToolProtocolErrors.has(result.error.code));
+}
+function planItemsFromToolResult(result) {
+    if (!result.ok || result.toolName !== 'todo_write') {
+        return undefined;
+    }
+    const parsed = parseToolOutput(result.output);
+    return planItemsFromRawItems(parsed?.['items']);
+}
+function toolResultMessageContent(result, call) {
+    if (result.ok) {
+        return result.output;
+    }
+    const guidance = repeatedToolCallRecoveryGuidance(result) ?? toolArgumentRecoveryGuidance(result) ?? runCommandRecoveryGuidance(result, call);
+    return JSON.stringify({
+        ok: false,
+        error: result.error,
+        ...(guidance ? { guidance } : {}),
+    });
+}
+function repeatedToolCallRecoveryGuidance(result) {
+    if (result.ok || result.error.code !== 'REPEATED_TOOL_CALL') {
+        return undefined;
+    }
+    return [
+        'Do not call the same tool again with identical arguments in this turn.',
+        'Use the previous result if it answered the question.',
+        'If more evidence is needed, change the path, query, glob, or command so the next tool call can produce new information.',
+    ].join(' ');
+}
+function toolArgumentRecoveryGuidance(result) {
+    if (result.ok || result.error.code !== 'TOOL_ARGUMENTS_INVALID') {
+        return undefined;
+    }
+    return [
+        'Retry the same tool call with arguments as a strict JSON object.',
+        'Quote string values such as filesystem paths.',
+        'Include every required field from the tool schema.',
+        'Example for a path argument: {"path":"/absolute/or/relative/path"}.',
+    ].join(' ');
+}
+function runCommandRecoveryGuidance(result, call) {
+    if (result.ok ||
+        (result.toolName !== 'run_command' && result.toolName !== 'execute_shell') ||
+        !['PERMISSION_DENIED', 'PERMISSION_REQUIRED', 'COMMAND_DENIED'].includes(result.error.code)) {
+        return undefined;
+    }
+    const requestedCommand = typeof call?.input['command'] === 'string' ? call.input['command'] : undefined;
+    if (requestedCommand && /\b(?:rm|rmdir)\b/.test(requestedCommand)) {
+        if (result.toolName === 'run_command') {
+            return [
+                'run_command cannot run rm/rmdir deletion.',
+                'Prefer delete_file for regular files and delete_directory for empty directories.',
+                'If the user specifically needs the Unix command form, use execute_shell with a simple rm/rmdir command and the correct cwd so approval can be requested.',
+                'Do not retry with pipes, redirects, command substitution, shell wrappers, cd, or a broader command.',
+            ].join(' ');
+        }
+        return [
+            'This rm/rmdir command was not allowed.',
+            'Do not retry with a broader or more complex shell form.',
+            'Prefer delete_file for regular files and delete_directory for empty directories when those tools can express the target.',
+            'If the safety policy blocked the target, explain the exact blocker instead of claiming deletion.',
+        ].join(' ');
+    }
+    if (result.toolName === 'execute_shell') {
+        return [
+            'Do not retry with pipes, redirects, command substitution, environment assignment, or another shell wrapper.',
+            'If approval was denied, finish the file work that can be done safely and tell the user the exact validation command to run manually.',
+        ].join(' ');
+    }
+    return [
+        'Do not retry this command in another shell form.',
+        'run_command only supports safe read-only local inspection commands and read-only git subcommands.',
+        'If this was a build/test/validation command that can be expressed as a simple command, call execute_shell with its cwd set to the target project directory so the runtime can request approval.',
+        'Do not pass cd, pipes, redirects, backgrounding, command substitution, shell wrappers, or environment assignments to execute_shell.',
+        'If it cannot be expressed with execute_shell, finish the file work and tell the user the manual command to run.',
+    ].join(' ');
+}
+function appendToolTranscriptEvents(cwd, sessionStore, events) {
+    const artifacts = new Map();
+    for (const event of events) {
+        if (event.type === 'tool_call') {
+            sessionStore.append({
+                type: 'tool_call',
+                callId: event.callId,
+                toolName: event.toolName,
+                input: event.input,
+                status: event.status,
+            });
+            continue;
+        }
+        const artifact = maybeWriteToolResultArtifact(cwd, sessionStore.sessionId, event);
+        if (artifact) {
+            artifacts.set(event.callId, artifact);
+        }
+        sessionStore.append({
+            type: 'tool_result',
+            callId: event.callId,
+            toolName: event.toolName,
+            ok: event.ok,
+            summary: event.ok ? summarizeToolOutput(event.summary, event.truncated) : event.summary,
+            ...(event.bytes !== undefined ? { bytes: event.bytes } : {}),
+            ...(event.truncated !== undefined ? { truncated: event.truncated } : {}),
+            ...(event.errorCode !== undefined ? { errorCode: event.errorCode } : {}),
+            ...(artifact ? { artifact } : {}),
+        });
+    }
+    return artifacts;
+}
+function maybeWriteToolResultArtifact(cwd, sessionId, event) {
+    if (!event.ok || !shouldWriteToolResultArtifact(event)) {
+        return undefined;
+    }
+    return writeToolResultArtifact(cwd, sessionId, {
+        callId: event.callId,
+        toolName: event.toolName,
+        content: event.summary,
+        contentType: looksLikeJson(event.summary) ? 'application/json' : 'text/plain',
+    });
+}
+function shouldWriteToolResultArtifact(event) {
+    const bytes = event.bytes ?? Buffer.byteLength(event.summary, 'utf8');
+    return event.truncated === true || bytes >= toolResultArtifactThresholdBytes;
+}
+function looksLikeJson(value) {
+    const trimmed = value.trim();
+    return (trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'));
+}
+function recordRecalledMemoryUse(cwd, memoryIds) {
+    if (memoryIds.length === 0) {
+        return;
+    }
+    try {
+        recordMemoryUse(cwd, memoryIds);
+    }
+    catch {
+        // Memory usage stats must never fail the user-facing chat turn.
+    }
+}
+function recordSessionMemoryIfNeeded(cwd, sessionId, config) {
+    if (config.sessionStore || config.disableSessionMemory) {
+        return;
+    }
+    try {
+        maybeUpdateSessionMemory(cwd, sessionId, {
+            ...(config.maxSessionMemoryChars !== undefined ? { maxSummaryChars: config.maxSessionMemoryChars } : {}),
+            ...(config.sessionMemoryMinimumTokensToInit !== undefined ? { minimumTokensToInit: config.sessionMemoryMinimumTokensToInit } : {}),
+            ...(config.sessionMemoryMinimumTokensBetweenUpdates !== undefined ? { minimumTokensBetweenUpdates: config.sessionMemoryMinimumTokensBetweenUpdates } : {}),
+            ...(config.sessionMemoryToolCallsBetweenUpdates !== undefined ? { toolCallsBetweenUpdates: config.sessionMemoryToolCallsBetweenUpdates } : {}),
+        });
+    }
+    catch {
+        // Session memory is continuity help. It must never fail the active user turn.
+    }
+}
+function allowedReadRoots(cwd, env) {
+    const roots = [cwd];
+    if (env.HOME && env.HOME !== cwd) {
+        roots.push(env.HOME);
+    }
+    return roots;
+}
+function allowedWriteRoots(cwd, env) {
+    void env;
+    return [cwd];
+}
+function latestPermissionRules(cwd, env, runtimeRules = []) {
+    return [...(loadRemiConfig({ cwd, env }).config.permissions?.allow ?? []), ...runtimeRules];
+}
+function runtimePermissionRules(source) {
+    if (!source) {
+        return [];
+    }
+    return typeof source === 'function' ? source() : source;
+}
+function mergeTokenUsage(current, next) {
+    return {
+        inputTokens: (current?.inputTokens ?? 0) + next.inputTokens,
+        outputTokens: (current?.outputTokens ?? 0) + next.outputTokens,
+        totalTokens: normalizedTokenUsageTotal(current) + normalizedTokenUsageTotal(next),
+        ...mergeOptionalTokenField('cachedInputTokens', current, next),
+        ...mergeOptionalTokenField('reasoningOutputTokens', current, next),
+    };
+}
+function tokenUsageDelta(previous, next) {
+    const inputTokens = Math.max(0, next.inputTokens - (previous?.inputTokens ?? 0));
+    const outputTokens = Math.max(0, next.outputTokens - (previous?.outputTokens ?? 0));
+    const cachedInputTokens = optionalTokenDelta(previous?.cachedInputTokens, next.cachedInputTokens);
+    const reasoningOutputTokens = optionalTokenDelta(previous?.reasoningOutputTokens, next.reasoningOutputTokens);
+    const totalTokens = Math.max(0, normalizedTokenUsageTotal(next) - normalizedTokenUsageTotal(previous));
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    };
+}
+function optionalTokenDelta(previous, next) {
+    if (previous === undefined && next === undefined) {
+        return undefined;
+    }
+    return Math.max(0, (next ?? 0) - (previous ?? 0));
+}
+function hasTokenUsage(usage) {
+    return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.totalTokens > 0 || (usage.cachedInputTokens ?? 0) > 0 || (usage.reasoningOutputTokens ?? 0) > 0;
+}
+function normalizedTokenUsageTotal(usage) {
+    if (!usage) {
+        return 0;
+    }
+    return Math.max(usage.totalTokens, usage.inputTokens + usage.outputTokens + (usage.cachedInputTokens ?? 0));
+}
+function mergeOptionalTokenField(field, current, next) {
+    const currentValue = current?.[field];
+    const nextValue = next[field];
+    if (currentValue === undefined && nextValue === undefined) {
+        return {};
+    }
+    return { [field]: (currentValue ?? 0) + (nextValue ?? 0) };
+}
+function parseToolOutput(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function summarizeParsedToolOutput(output) {
+    if (Array.isArray(output['items'])) {
+        return `plan updated (${output['items'].length} ${output['items'].length === 1 ? 'item' : 'items'})`;
+    }
+    if (Array.isArray(output['entries'])) {
+        return summarizePathArray('entries', output['entries'], output['path']);
+    }
+    if (Array.isArray(output['matches'])) {
+        return summarizePathArray('matches', output['matches'], output['path']);
+    }
+    if (typeof output['content'] === 'string') {
+        const bytes = typeof output['bytes'] === 'number' ? output['bytes'] : output['content'].length;
+        const path = typeof output['path'] === 'string' ? ` from ${output['path']}` : '';
+        return `read ${bytes} bytes${path}`;
+    }
+    if (typeof output['path'] === 'string' && typeof output['created'] === 'boolean' && typeof output['bytes'] !== 'number') {
+        return `${output['created'] ? 'created' : 'exists'} ${output['path']}`;
+    }
+    if (typeof output['path'] === 'string' &&
+        output['deleted'] === true &&
+        typeof output['addedLines'] === 'number' &&
+        typeof output['removedLines'] === 'number') {
+        return `deleted ${output['path']} (+${output['addedLines']} -${output['removedLines']})`;
+    }
+    if (typeof output['path'] === 'string' && output['deleted'] === true) {
+        return `deleted ${output['path']}`;
+    }
+    if (typeof output['path'] === 'string' && typeof output['bytes'] === 'number') {
+        if (typeof output['addedLines'] === 'number' && typeof output['removedLines'] === 'number') {
+            return `edited ${output['path']} (+${output['addedLines']} -${output['removedLines']})`;
+        }
+        const overwritten = output['overwritten'] === true;
+        return `${overwritten ? 'updated' : 'created'} ${output['path']} (${output['bytes']} bytes)`;
+    }
+    if (typeof output['command'] === 'string' && typeof output['stdout'] === 'string') {
+        const exitCode = typeof output['exitCode'] === 'number' ? output['exitCode'] : 0;
+        const stderr = typeof output['stderr'] === 'string' ? output['stderr'] : '';
+        const preview = compactText(output['stdout'] || stderr, 160);
+        return preview.length > 0 ? `exit ${exitCode}: ${preview}` : `exit ${exitCode}`;
+    }
+    return compactText(JSON.stringify(output), 240);
+}
+function summarizePathArray(label, rawItems, rawPath) {
+    const items = rawItems
+        .map(item => {
+        if (typeof item === 'string') {
+            return item;
+        }
+        if (!item || typeof item !== 'object') {
+            return undefined;
+        }
+        const record = item;
+        const path = typeof record['path'] === 'string' ? record['path'] : undefined;
+        const line = typeof record['line'] === 'number' ? record['line'] : undefined;
+        return path && line !== undefined ? `${path}:${line}` : path;
+    })
+        .filter((item) => Boolean(item));
+    const prefix = `${rawItems.length} ${label}`;
+    const root = typeof rawPath === 'string' ? ` in ${rawPath}` : '';
+    const preview = items.slice(0, 4).join(', ');
+    return preview.length > 0 ? `${prefix}${root}: ${preview}` : `${prefix}${root}`;
+}
+function compactText(text, maxLength) {
+    const compacted = text.replace(/\s+/g, ' ').trim();
+    return compacted.length > maxLength ? `${compacted.slice(0, maxLength - 3)}...` : compacted;
+}
+function joinCommandOutput(stdout, stderr) {
+    if (!stdout) {
+        return stderr;
+    }
+    if (!stderr) {
+        return stdout;
+    }
+    return stdout.endsWith('\n') ? `${stdout}${stderr}` : `${stdout}\n${stderr}`;
+}
+function compactMultilineOutput(text, maxLength) {
+    const trimmed = text.replace(/\r\n/g, '\n').trimEnd();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    return trimmed.length > maxLength ? `${trimmed.slice(0, maxLength - 24)}\n... output truncated ...` : trimmed;
+}
+function safeErrorMessage(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    return error.message.replace(/Bearer\s+[A-Za-z0-9._-]+/g, 'Bearer [redacted]');
+}