@iaforged/context-code 1.3.5 → 1.3.6

package/dist/src/core/session/branchCore.js

@@ -0,0 +1,103 @@
+export function deriveFirstPromptCore(firstUserMessage) {
+    const content = firstUserMessage?.message?.content;
+    if (!content)
+        return 'Branched conversation';
+    const raw = typeof content === 'string'
+        ? content
+        : content.find((block) => block.type === 'text')?.text;
+    if (!raw)
+        return 'Branched conversation';
+    return (raw.replace(/\s+/g, ' ').trim().slice(0, 100) || 'Branched conversation');
+}
+export async function getUniqueForkNameCore(deps, baseName) {
+    const candidateName = `${baseName} (Branch)`;
+    const existingWithExactName = await deps.searchSessionsByCustomTitle(candidateName, { exact: true });
+    if (existingWithExactName.length === 0)
+        return candidateName;
+    const existingForks = await deps.searchSessionsByCustomTitle(`${baseName} (Branch`);
+    const usedNumbers = new Set([1]);
+    const forkNumberPattern = new RegExp(`^${deps.escapeRegExp(baseName)} \\(Branch(?: (\\d+))?\\)$`);
+    for (const session of existingForks) {
+        const match = session.customTitle?.match(forkNumberPattern);
+        if (!match)
+            continue;
+        usedNumbers.add(match[1] ? parseInt(match[1], 10) : 1);
+    }
+    let nextNumber = 2;
+    while (usedNumbers.has(nextNumber))
+        nextNumber++;
+    return `${baseName} (Branch ${nextNumber})`;
+}
+export async function createForkCore(deps, input) {
+    const forkSessionId = deps.randomUUID();
+    const projectDir = deps.getProjectDir(input.originalCwd);
+    const forkSessionPath = deps.getTranscriptPathForSession(forkSessionId);
+    const currentTranscriptPath = deps.getTranscriptPath();
+    await deps.mkdir(projectDir);
+    let transcriptContent;
+    try {
+        transcriptContent = await deps.readFile(currentTranscriptPath);
+    }
+    catch {
+        throw new Error('No conversation to branch');
+    }
+    if (transcriptContent.length === 0)
+        throw new Error('No conversation to branch');
+    const entries = deps.parseJSONL(transcriptContent);
+    const mainConversationEntries = entries.filter((entry) => deps.isTranscriptMessage(entry) && !entry.isSidechain);
+    const contentReplacementRecords = entries
+        .filter((entry) => entry.type === 'content-replacement' &&
+        entry.sessionId === input.originalSessionId)
+        .flatMap(entry => entry.replacements);
+    if (mainConversationEntries.length === 0)
+        throw new Error('No messages to branch');
+    let parentUuid = null;
+    const lines = [];
+    const serializedMessages = [];
+    for (const entry of mainConversationEntries) {
+        const forkedEntry = {
+            ...entry,
+            sessionId: forkSessionId,
+            parentUuid,
+            isSidechain: false,
+            forkedFrom: {
+                sessionId: input.originalSessionId,
+                messageUuid: entry.uuid,
+            },
+        };
+        serializedMessages.push({ ...entry, sessionId: forkSessionId });
+        lines.push(deps.jsonStringify(forkedEntry));
+        if (entry.type !== 'progress')
+            parentUuid = entry.uuid;
+    }
+    if (contentReplacementRecords.length > 0) {
+        lines.push(deps.jsonStringify({
+            type: 'content-replacement',
+            sessionId: forkSessionId,
+            replacements: contentReplacementRecords,
+        }));
+    }
+    await deps.writeFile(forkSessionPath, `${lines.join('\n')}\n`);
+    return {
+        sessionId: forkSessionId,
+        forkPath: forkSessionPath,
+        serializedMessages,
+        contentReplacementRecords,
+    };
+}
+export function buildForkLogCore(input) {
+    return {
+        date: input.now.toISOString().split('T')[0],
+        messages: input.serializedMessages,
+        fullPath: input.forkPath,
+        value: input.now.getTime(),
+        created: input.now,
+        modified: input.now,
+        firstPrompt: input.firstPrompt,
+        messageCount: input.serializedMessages.length,
+        isSidechain: false,
+        sessionId: input.sessionId,
+        customTitle: input.customTitle,
+        contentReplacements: input.contentReplacementRecords,
+    };
+}

package/dist/src/core/session/branchCore.smoke.js

@@ -0,0 +1,20 @@
+import { deriveFirstPromptCore } from './branchCore.js';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+export function runBranchCoreSmoke() {
+    const prompt = deriveFirstPromptCore({
+        message: { content: 'Hello\nworld' },
+    });
+    assert(prompt === 'Hello world', 'expected normalized prompt');
+    const branchCommandSrc = readFileSync(resolve(process.cwd(), 'src', 'commands', 'branch', 'branch.ts'), 'utf8');
+    assert(branchCommandSrc.includes('getCurrentSessionId') &&
+        branchCommandSrc.includes('saveBranchCustomTitle'), 'expected branch command to use core/session cli adapter wiring');
+}
+if (import.meta.url === `file://${process.argv[1]?.replace(/\\/g, '/')}`) {
+    runBranchCoreSmoke();
+    console.log('session.branchCore.smoke PASS');
+}

package/dist/src/core/session/briefCliAdapter.js

@@ -0,0 +1,4 @@
+export { getKairosActive, setUserMsgOptIn } from '../../bootstrap/state.js';
+export { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+export { logEvent, } from '../../services/analytics/index.js';
+export { lazySchema } from '../../utils/lazySchema.js';

package/dist/src/core/session/clearCachesCore.js

@@ -0,0 +1,33 @@
+export function clearSessionCachesCore(deps, preservedAgentIds = new Set()) {
+    const hasPreserved = preservedAgentIds.size > 0;
+    deps.clearContextCaches();
+    deps.clearFileSuggestionCaches();
+    deps.clearCommandsCache();
+    if (!hasPreserved)
+        deps.resetPromptCacheBreakDetection();
+    deps.clearSystemPromptInjection();
+    deps.clearLastEmittedDate();
+    deps.runPostCompactCleanup();
+    deps.resetSentSkillNames();
+    deps.resetGetMemoryFilesCache();
+    deps.clearStoredImagePaths();
+    deps.clearAllSessions();
+    if (!hasPreserved)
+        deps.clearAllPendingCallbacks();
+    deps.clearTungstenUsageCaches();
+    deps.clearAttributionCaches();
+    deps.clearRepositoryCaches();
+    deps.clearCommandPrefixCaches();
+    if (!hasPreserved)
+        deps.clearAllDumpState();
+    deps.clearInvokedSkills(preservedAgentIds);
+    deps.clearResolveGitDirCache();
+    deps.clearDynamicSkills();
+    deps.resetAllLspDiagnosticState();
+    deps.clearTrackedMagicDocs();
+    deps.clearSessionEnvVars();
+    deps.clearWebFetchCache();
+    deps.clearToolSearchDescriptionCache();
+    deps.clearAgentDefinitionsCache();
+    deps.clearSkillPromptCache();
+}

package/dist/src/core/session/clearConversationCore.js

@@ -0,0 +1,37 @@
+export async function clearConversationCore(input, deps) {
+    const timeoutMs = deps.getSessionEndHookTimeoutMs();
+    await deps.executeSessionEndHooks({
+        timeoutMs,
+    });
+    if (input.lastRequestId)
+        deps.logCacheEvictionHint(input.lastRequestId);
+    const preserved = deps.getPreservedTaskSnapshot?.() ?? {
+        preservedAgentIds: new Set(),
+        preservedLocalAgentTaskIds: [],
+    };
+    deps.setMessagesEmpty();
+    if (input.hasProactiveFeature)
+        deps.setContextBlocked(false);
+    deps.setConversationId?.();
+    deps.clearSessionCaches(preserved.preservedAgentIds);
+    deps.setCwd(input.originalCwd);
+    deps.clearReadFileState();
+    deps.clearDiscoveredSkillNames();
+    deps.clearLoadedNestedMemoryPaths();
+    deps.clearAppState?.({ preservedTaskIds: new Set(preserved.preservedLocalAgentTaskIds) });
+    deps.clearPlanSlugs();
+    deps.clearSessionMetadata();
+    deps.regenerateSessionId();
+    if (input.shouldUpdateEnvSessionId && input.userType === 'ant' && input.envSessionId) {
+        process.env.CLAUDE_CODE_SESSION_ID = deps.getSessionId();
+    }
+    await deps.resetSessionFilePointer();
+    deps.refreshRunningTaskOutputLinks(preserved.preservedLocalAgentTaskIds);
+    if (input.hasCoordinatorModeFeature) {
+        deps.saveMode?.();
+    }
+    deps.saveWorktreeState?.();
+    const hookMessages = await deps.processSessionStartHooks();
+    if (hookMessages.length > 0)
+        deps.setMessagesToHookMessages(hookMessages);
+}

package/dist/src/core/session/cliAdapter.js

@@ -0,0 +1,2 @@
+export * from './legacy/cliAdapter.impl.js';
+export { FileStateCache } from '../../utils/fileStateCache.js';

package/dist/src/core/session/colorCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/colorCliAdapter.impl.js';

package/dist/src/core/session/colorCore.js

@@ -0,0 +1,7 @@
+export const RESET_COLOR_ALIASES = ['default', 'reset', 'none', 'gray', 'grey'];
+export function normalizeColorArg(args) {
+    return args.trim().toLowerCase();
+}
+export function isResetColorAlias(colorArg) {
+    return RESET_COLOR_ALIASES.includes(colorArg);
+}

package/dist/src/core/session/compactCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/compactCliAdapter.impl.js';

package/dist/src/core/session/compactCore.js

@@ -0,0 +1,112 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+import { markPostCompaction } from '../../bootstrap/state.js';
+import { ERROR_MESSAGE_INCOMPLETE_RESPONSE, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES, ERROR_MESSAGE_USER_ABORT, compactConversation, mergeHookInstructions, microcompactMessages, notifyCompaction, runPostCompactCleanup, setLastSummarizedMessageId, suppressCompactWarning, trySessionMemoryCompaction, } from './legacy/compactCliAdapter.js';
+import { executePreCompactHooks, hasExactErrorMessage } from './legacy/compactCliAdapter.js';
+export async function executeCompactCore(args, context, deps) {
+    const { abortController } = context;
+    let messages = deps.getMessagesAfterCompactBoundary(context.messages);
+    if (messages.length === 0) {
+        throw new Error('No messages to compact');
+    }
+    const customInstructions = args.trim();
+    try {
+        if (!customInstructions) {
+            const sessionMemoryResult = await trySessionMemoryCompaction(messages, context.agentId);
+            if (sessionMemoryResult) {
+                deps.getUserCacheClear()?.();
+                runPostCompactCleanup();
+                if (feature('PROMPT_CACHE_BREAK_DETECTION')) {
+                    notifyCompaction(context.options.querySource ?? 'compact', context.agentId);
+                }
+                markPostCompaction();
+                suppressCompactWarning();
+                return {
+                    type: 'compact',
+                    compactionResult: sessionMemoryResult,
+                    displayText: deps.buildDisplayText(context),
+                };
+            }
+        }
+        if (deps.reactiveCompact?.isReactiveOnlyMode()) {
+            return await compactViaReactive(messages, context, customInstructions, deps);
+        }
+        const microcompactResult = await microcompactMessages(messages, context);
+        messages = microcompactResult.messages;
+        const result = await compactConversation(messages, context, await deps.getCacheSharingParams(context, messages), false, customInstructions, false);
+        setLastSummarizedMessageId(undefined);
+        suppressCompactWarning();
+        deps.getUserCacheClear()?.();
+        runPostCompactCleanup();
+        return {
+            type: 'compact',
+            compactionResult: result,
+            displayText: deps.buildDisplayText(context, result.userDisplayMessage),
+        };
+    }
+    catch (error) {
+        if (abortController.signal.aborted) {
+            throw new Error('Compaction canceled.');
+        }
+        if (hasExactErrorMessage(error, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)) {
+            throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+        }
+        if (hasExactErrorMessage(error, ERROR_MESSAGE_INCOMPLETE_RESPONSE)) {
+            throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+        }
+        deps.logError(error);
+        throw new Error(`Error during compaction: ${error}`);
+    }
+}
+async function compactViaReactive(messages, context, customInstructions, deps) {
+    const reactive = deps.reactiveCompact;
+    if (!reactive)
+        throw new Error('Reactive compact runtime not available');
+    context.onCompactProgress?.({ type: 'hooks_start', hookType: 'pre_compact' });
+    context.setSDKStatus?.('compacting');
+    try {
+        const [hookResult, cacheSafeParams] = await Promise.all([
+            executePreCompactHooks({ trigger: 'manual', customInstructions: customInstructions || null }, context.abortController.signal),
+            deps.getCacheSharingParams(context, messages),
+        ]);
+        const mergedInstructions = mergeHookInstructions(customInstructions, hookResult.newCustomInstructions);
+        context.setStreamMode?.('requesting');
+        context.setResponseLength?.(() => 0);
+        context.onCompactProgress?.({ type: 'compact_start' });
+        const outcome = await reactive.reactiveCompactOnPromptTooLong(messages, cacheSafeParams, {
+            customInstructions: mergedInstructions,
+            trigger: 'manual',
+        });
+        if (!outcome.ok) {
+            switch (outcome.reason) {
+                case 'too_few_groups':
+                    throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+                case 'aborted':
+                    throw new Error(ERROR_MESSAGE_USER_ABORT);
+                case 'exhausted':
+                case 'error':
+                case 'media_unstrippable':
+                    throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+            }
+        }
+        setLastSummarizedMessageId(undefined);
+        runPostCompactCleanup();
+        suppressCompactWarning();
+        deps.getUserCacheClear()?.();
+        const combinedMessage = [hookResult.userDisplayMessage, outcome.result.userDisplayMessage].filter(Boolean).join('\n') ||
+            undefined;
+        return {
+            type: 'compact',
+            compactionResult: {
+                ...outcome.result,
+                userDisplayMessage: combinedMessage,
+            },
+            displayText: deps.buildDisplayText(context, combinedMessage),
+        };
+    }
+    finally {
+        context.setStreamMode?.('requesting');
+        context.setResponseLength?.(() => 0);
+        context.onCompactProgress?.({ type: 'compact_end' });
+        context.setSDKStatus?.(null);
+    }
+}

package/dist/src/core/session/contextCore.js

@@ -0,0 +1,160 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+import { createRequire } from 'module';
+import { analyzeContextUsage, formatTokens, getMessagesAfterCompactBoundary, getSourceDisplayName, microcompactMessages, plural, } from './legacy/contextCliAdapter.js';
+const require = createRequire(import.meta.url);
+export function toApiView(messages) {
+    let view = getMessagesAfterCompactBoundary(messages);
+    if (feature('CONTEXT_COLLAPSE')) {
+        const { projectView } = require('./legacy/contextCollapseOperations.js');
+        view = projectView(view);
+    }
+    return view;
+}
+export async function collectContextDataCore(context) {
+    const { messages, getAppState, options: { mainLoopModel, tools, agentDefinitions, customSystemPrompt, appendSystemPrompt, }, } = context;
+    const apiView = toApiView(messages);
+    const { messages: compactedMessages } = await microcompactMessages(apiView);
+    const appState = getAppState();
+    return analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, agentDefinitions, undefined, { options: { customSystemPrompt, appendSystemPrompt } }, undefined, apiView);
+}
+export function formatContextAsMarkdownTableCore(data) {
+    const { categories, totalTokens, rawMaxTokens, percentage, model, memoryFiles, mcpTools, agents, skills, messageBreakdown, systemTools, systemPromptSections, } = data;
+    let output = `## Context Usage\n\n`;
+    output += `**Model:** ${model}  \n`;
+    output += `**Tokens:** ${formatTokens(totalTokens)} / ${formatTokens(rawMaxTokens)} (${percentage}%)\n`;
+    if (feature('CONTEXT_COLLAPSE')) {
+        const { getStats, isContextCollapseEnabled } = require('./legacy/contextCollapseIndex.js');
+        if (isContextCollapseEnabled()) {
+            const s = getStats();
+            const { health: h } = s;
+            const parts = [];
+            if (s.collapsedSpans > 0) {
+                parts.push(`${s.collapsedSpans} ${plural(s.collapsedSpans, 'span')} summarized (${s.collapsedMessages} messages)`);
+            }
+            if (s.stagedSpans > 0)
+                parts.push(`${s.stagedSpans} staged`);
+            const summary = parts.length > 0
+                ? parts.join(', ')
+                : h.totalSpawns > 0
+                    ? `${h.totalSpawns} ${plural(h.totalSpawns, 'spawn')}, nothing staged yet`
+                    : 'waiting for first trigger';
+            output += `**Context strategy:** collapse (${summary})\n`;
+            if (h.totalErrors > 0) {
+                output += `**Collapse errors:** ${h.totalErrors}/${h.totalSpawns} spawns failed`;
+                if (h.lastError)
+                    output += ` (last: ${h.lastError.slice(0, 80)})`;
+                output += '\n';
+            }
+            else if (h.emptySpawnWarningEmitted) {
+                output += `**Collapse idle:** ${h.totalEmptySpawns} consecutive empty runs\n`;
+            }
+        }
+    }
+    output += '\n';
+    const visibleCategories = categories.filter(cat => cat.tokens > 0 &&
+        cat.name !== 'Free space' &&
+        cat.name !== 'Autocompact buffer');
+    if (visibleCategories.length > 0) {
+        output += `### Estimated usage by category\n\n`;
+        output += `| Category | Tokens | Percentage |\n`;
+        output += `|----------|--------|------------|\n`;
+        for (const cat of visibleCategories) {
+            const percentDisplay = ((cat.tokens / rawMaxTokens) * 100).toFixed(1);
+            output += `| ${cat.name} | ${formatTokens(cat.tokens)} | ${percentDisplay}% |\n`;
+        }
+        const freeSpaceCategory = categories.find(c => c.name === 'Free space');
+        if (freeSpaceCategory && freeSpaceCategory.tokens > 0) {
+            const percentDisplay = ((freeSpaceCategory.tokens / rawMaxTokens) * 100).toFixed(1);
+            output += `| Free space | ${formatTokens(freeSpaceCategory.tokens)} | ${percentDisplay}% |\n`;
+        }
+        const autocompactCategory = categories.find(c => c.name === 'Autocompact buffer');
+        if (autocompactCategory && autocompactCategory.tokens > 0) {
+            const percentDisplay = ((autocompactCategory.tokens / rawMaxTokens) * 100).toFixed(1);
+            output += `| Autocompact buffer | ${formatTokens(autocompactCategory.tokens)} | ${percentDisplay}% |\n`;
+        }
+        output += `\n`;
+    }
+    if (mcpTools.length > 0) {
+        output += `### MCP Tools\n\n`;
+        output += `| Tool | Server | Tokens |\n|------|--------|--------|\n`;
+        for (const tool of mcpTools) {
+            output += `| ${tool.name} | ${tool.serverName} | ${formatTokens(tool.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (systemTools && systemTools.length > 0 && process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] System Tools\n\n`;
+        output += `| Tool | Tokens |\n|------|--------|\n`;
+        for (const tool of systemTools) {
+            output += `| ${tool.name} | ${formatTokens(tool.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (systemPromptSections && systemPromptSections.length > 0 && process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] System Prompt Sections\n\n`;
+        output += `| Section | Tokens |\n|---------|--------|\n`;
+        for (const section of systemPromptSections) {
+            output += `| ${section.name} | ${formatTokens(section.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (agents.length > 0) {
+        output += `### Custom Agents\n\n`;
+        output += `| Agent Type | Source | Tokens |\n|------------|--------|--------|\n`;
+        for (const agent of agents) {
+            let sourceDisplay;
+            switch (agent.source) {
+                case 'projectSettings':
+                    sourceDisplay = 'Project';
+                    break;
+                case 'userSettings':
+                    sourceDisplay = 'User';
+                    break;
+                case 'localSettings':
+                    sourceDisplay = 'Local';
+                    break;
+                case 'flagSettings':
+                    sourceDisplay = 'Flag';
+                    break;
+                case 'policySettings':
+                    sourceDisplay = 'Policy';
+                    break;
+                case 'plugin':
+                    sourceDisplay = 'Plugin';
+                    break;
+                case 'built-in':
+                    sourceDisplay = 'Built-in';
+                    break;
+                default: sourceDisplay = String(agent.source);
+            }
+            output += `| ${agent.agentType} | ${sourceDisplay} | ${formatTokens(agent.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (memoryFiles.length > 0) {
+        output += `### Memory Files\n\n`;
+        output += `| Type | Path | Tokens |\n|------|------|--------|\n`;
+        for (const file of memoryFiles) {
+            output += `| ${file.type} | ${file.path} | ${formatTokens(file.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (skills && skills.tokens > 0 && skills.skillFrontmatter.length > 0) {
+        output += `### Skills\n\n`;
+        output += `| Skill | Source | Tokens |\n|-------|--------|--------|\n`;
+        for (const skill of skills.skillFrontmatter) {
+            output += `| ${skill.name} | ${getSourceDisplayName(skill.source)} | ${formatTokens(skill.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    if (messageBreakdown && process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] Message Breakdown\n\n`;
+        output += `| Category | Tokens |\n|----------|--------|\n`;
+        output += `| Tool calls | ${formatTokens(messageBreakdown.toolCallTokens)} |\n`;
+        output += `| Tool results | ${formatTokens(messageBreakdown.toolResultTokens)} |\n`;
+        output += `| Attachments | ${formatTokens(messageBreakdown.attachmentTokens)} |\n`;
+        output += `| Assistant messages (non-tool) | ${formatTokens(messageBreakdown.assistantMessageTokens)} |\n`;
+        output += `| User messages (non-tool-result) | ${formatTokens(messageBreakdown.userMessageTokens)} |\n\n`;
+    }
+    return output;
+}

package/dist/src/core/session/contextRenderCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/contextRenderCliAdapter.impl.js';

package/dist/src/core/session/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/session/copyCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/copyCliAdapter.impl.js';

package/dist/src/core/session/exitCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/exitCliAdapter.impl.js';

package/dist/src/core/session/exportCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/exportCliAdapter.impl.js';

package/dist/src/core/session/exportCore.js

@@ -0,0 +1,59 @@
+import { join } from 'path';
+import { getCwd, renderMessagesToPlainText, writeFileSync_DEPRECATED } from './exportCliAdapter.js';
+export function formatTimestampCore(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+export function extractFirstPromptCore(messages) {
+    const firstUserMessage = messages.find(msg => msg.type === 'user');
+    if (!firstUserMessage || firstUserMessage.type !== 'user')
+        return '';
+    const content = firstUserMessage.message?.content;
+    let result = '';
+    if (typeof content === 'string') {
+        result = content.trim();
+    }
+    else if (Array.isArray(content)) {
+        const textContent = content.find(item => item.type === 'text');
+        if (textContent && 'text' in textContent)
+            result = textContent.text.trim();
+    }
+    result = result.split('\n')[0] || '';
+    if (result.length > 50)
+        result = `${result.substring(0, 49)}…`;
+    return result;
+}
+export function sanitizeFilenameCore(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export async function exportWithReactRendererCore(context) {
+    const tools = context.options.tools || [];
+    return renderMessagesToPlainText(context.messages, tools);
+}
+export function writeConversationExportCore(filename, content) {
+    const finalFilename = filename.endsWith('.txt') ? filename : `${filename.replace(/\.[^.]+$/, '')}.txt`;
+    const filepath = join(getCwd(), finalFilename);
+    writeFileSync_DEPRECATED(filepath, content, {
+        encoding: 'utf-8',
+        flush: true,
+    });
+    return filepath;
+}
+export function buildDefaultExportFilenameCore(messages, now = new Date()) {
+    const firstPrompt = extractFirstPromptCore(messages);
+    const timestamp = formatTimestampCore(now);
+    if (!firstPrompt)
+        return `conversation-${timestamp}.txt`;
+    const sanitized = sanitizeFilenameCore(firstPrompt);
+    return sanitized ? `${timestamp}-${sanitized}.txt` : `conversation-${timestamp}.txt`;
+}

package/dist/src/core/session/filesCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/filesCliAdapter.impl.js';

package/dist/src/core/session/generateSessionNameCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/generateSessionNameCliAdapter.impl.js';

package/dist/src/core/session/generateSessionNameCore.js

@@ -0,0 +1,46 @@
+export async function generateSessionNameCore(messages, signal, deps) {
+    const conversationText = deps.extractConversationText(messages);
+    if (!conversationText) {
+        return null;
+    }
+    try {
+        const result = await deps.queryHaiku({
+            systemPrompt: deps.asSystemPrompt([
+                'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.',
+            ]),
+            userPrompt: conversationText,
+            outputFormat: {
+                type: 'json_schema',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                    },
+                    required: ['name'],
+                    additionalProperties: false,
+                },
+            },
+            signal,
+            options: {
+                querySource: 'rename_generate_name',
+                agents: [],
+                isNonInteractiveSession: false,
+                hasAppendSystemPrompt: false,
+                mcpTools: [],
+            },
+        });
+        const content = deps.extractTextContent(result.message.content);
+        const response = deps.safeParseJSON(content);
+        if (response &&
+            typeof response === 'object' &&
+            'name' in response &&
+            typeof response.name === 'string') {
+            return response.name;
+        }
+        return null;
+    }
+    catch (error) {
+        deps.logDebugError(error);
+        return null;
+    }
+}

package/dist/src/core/session/generateSessionNameCore.smoke.js

@@ -0,0 +1,23 @@
+import { generateSessionNameCore } from './generateSessionNameCore.js';
+export async function runGenerateSessionNameCoreSmoke() {
+    const messages = [{ role: 'user', content: 'fix login bug and auth flow' }];
+    const name = await generateSessionNameCore(messages, new AbortController().signal, {
+        extractConversationText: () => 'fix login bug and auth flow',
+        asSystemPrompt: parts => parts,
+        queryHaiku: async () => ({ message: { content: '{"name":"fix-login-bug"}' } }),
+        extractTextContent: content => String(content),
+        safeParseJSON: text => JSON.parse(text),
+        logDebugError: () => { },
+    });
+    if (name !== 'fix-login-bug') {
+        throw new Error('expected generated kebab-case name');
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runGenerateSessionNameCoreSmoke()
+        .then(() => console.log('session.generateSessionNameCore.smoke PASS'))
+        .catch(error => {
+        console.error('session.generateSessionNameCore.smoke FAIL', error);
+        process.exitCode = 1;
+    });
+}

package/dist/src/core/session/heapdumpCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/heapdumpCliAdapter.impl.js';

package/dist/src/core/session/initCliAdapter.js

@@ -0,0 +1 @@
+export { isEnvTruthy } from '../../utils/envUtils.js';

package/dist/src/core/session/keybindingsCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/keybindingsCliAdapter.impl.js';