@iaforged/context-code 1.3.5 → 1.3.6

package/dist/src/core/session/legacy/addDirCliAdapter.impl.js

@@ -0,0 +1,4 @@
+import { getAdditionalDirectoriesForClaudeMd, setAdditionalDirectoriesForClaudeMd, } from '../../../bootstrap/state.js';
+import { applyPermissionUpdate, persistPermissionUpdate, } from '../../../utils/permissions/PermissionUpdate.js';
+import { SandboxManager } from '../../../utils/sandbox/sandbox-adapter.js';
+export { applyPermissionUpdate, getAdditionalDirectoriesForClaudeMd, persistPermissionUpdate, SandboxManager, setAdditionalDirectoriesForClaudeMd, };

package/dist/src/core/session/legacy/addDirValidationCliAdapter.impl.js

@@ -0,0 +1,5 @@
+import { stat } from 'fs/promises';
+import { allWorkingDirectories, pathInWorkingPath } from '../../../utils/permissions/filesystem.js';
+import { getErrnoCode } from '../../../utils/errors.js';
+import { expandPath } from '../../../utils/path.js';
+export { allWorkingDirectories, expandPath, getErrnoCode, pathInWorkingPath, stat };

package/dist/src/core/session/legacy/branchCliAdapter.impl.js

@@ -0,0 +1,37 @@
+import { randomUUID } from 'crypto';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { getOriginalCwd, getSessionId } from '../../../bootstrap/state.js';
+import { logEvent } from '../../../services/analytics/index.js';
+import { parseJSONL } from '../../../utils/json.js';
+import { jsonStringify } from '../../../utils/slowOperations.js';
+import { escapeRegExp } from '../../../utils/stringUtils.js';
+import { getProjectDir, getTranscriptPath, getTranscriptPathForSession, isTranscriptMessage, searchSessionsByCustomTitle, saveCustomTitle, } from '../../../utils/sessionStorage.js';
+export const branchCliDeps = {
+    randomUUID: () => randomUUID(),
+    mkdir: path => mkdir(path, { recursive: true, mode: 0o700 }).then(() => undefined),
+    readFile,
+    writeFile: (path, data) => writeFile(path, data, {
+        encoding: 'utf8',
+        mode: 0o600,
+    }),
+    parseJSONL,
+    jsonStringify,
+    escapeRegExp,
+    getProjectDir,
+    getTranscriptPathForSession,
+    getTranscriptPath,
+    isTranscriptMessage,
+    searchSessionsByCustomTitle,
+};
+export function getCurrentSessionId() {
+    return getSessionId();
+}
+export function getCurrentOriginalCwd() {
+    return getOriginalCwd();
+}
+export async function saveBranchCustomTitle(sessionId, effectiveTitle, forkPath) {
+    await saveCustomTitle(sessionId, effectiveTitle, forkPath);
+}
+export function logBranchForkedEvent(input) {
+    logEvent('tengu_conversation_forked', input);
+}

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

@@ -0,0 +1,244 @@
+import { feature } from '../../../recovery/bunBundleShim.js';
+import { clearInvokedSkills, getLastMainRequestId, getOriginalCwd, getSessionId, regenerateSessionId, setLastEmittedDate, } from '../../../bootstrap/state.js';
+import { clearCommandsCache } from '../../../commands.js';
+import { getSessionStartDate } from '../../../constants/common.js';
+import { getGitStatus, getSystemContext, getUserContext, setSystemPromptInjection, } from '../../../context.js';
+import { clearFileSuggestionCaches } from '../../../hooks/fileSuggestions.js';
+import { clearAllPendingCallbacks } from '../../../hooks/useSwarmPermissionPoller.js';
+import { clearAllDumpState } from '../../../services/api/dumpPrompts.js';
+import { resetPromptCacheBreakDetection } from '../../../services/api/promptCacheBreakDetection.js';
+import { clearAllSessions } from '../../../services/api/sessionIngress.js';
+import { runPostCompactCleanup } from '../../../services/compact/postCompactCleanup.js';
+import { resetAllLSPDiagnosticState } from '../../../services/lsp/LSPDiagnosticRegistry.js';
+import { clearTrackedMagicDocs } from '../../../services/MagicDocs/magicDocs.js';
+import { clearDynamicSkills } from '../../../skills/loadSkillsDir.js';
+import { isInProcessTeammateTask } from '../../../tasks/InProcessTeammateTask/types.js';
+import { isLocalAgentTask, } from '../../../tasks/LocalAgentTask/LocalAgentTask.js';
+import { isLocalShellTask } from '../../../tasks/LocalShellTask/guards.js';
+import { asAgentId } from '../../../types/ids.js';
+import { resetSentSkillNames } from '../../../utils/attachments.js';
+import { clearCommandPrefixCaches } from '../../../utils/bash/commands.js';
+import { resetGetMemoryFilesCache } from '../../../utils/claudemd.js';
+import { createEmptyAttributionState } from '../../../utils/commitAttribution.js';
+import { clearRepositoryCaches } from '../../../utils/detectRepository.js';
+import { clearResolveGitDirCache } from '../../../utils/git/gitFilesystem.js';
+import { executeSessionEndHooks, getSessionEndHookTimeoutMs, } from '../../../utils/hooks.js';
+import { clearStoredImagePaths } from '../../../utils/imageStore.js';
+import { logError } from '../../../utils/log.js';
+import { clearAllPlanSlugs } from '../../../utils/plans.js';
+import { setCwd } from '../../../utils/Shell.js';
+import { clearSessionEnvVars } from '../../../utils/sessionEnvVars.js';
+import { processSessionStartHooks } from '../../../utils/sessionStart.js';
+import { clearSessionMetadata, getAgentTranscriptPath, resetSessionFilePointer, saveWorktreeState, } from '../../../utils/sessionStorage.js';
+import { evictTaskOutput, initTaskOutputAsSymlink, } from '../../../utils/task/diskOutput.js';
+import { getCurrentWorktreeSession } from '../../../utils/worktree.js';
+import { logEvent, } from '../../../services/analytics/index.js';
+export function createClearSessionCachesDeps() {
+    return {
+        clearContextCaches: () => {
+            getUserContext.cache.clear?.();
+            getSystemContext.cache.clear?.();
+            getGitStatus.cache.clear?.();
+            getSessionStartDate.cache.clear?.();
+        },
+        clearFileSuggestionCaches,
+        clearCommandsCache,
+        resetPromptCacheBreakDetection,
+        clearSystemPromptInjection: () => setSystemPromptInjection(null),
+        clearLastEmittedDate: () => setLastEmittedDate(null),
+        runPostCompactCleanup,
+        resetSentSkillNames,
+        resetGetMemoryFilesCache: () => resetGetMemoryFilesCache('session_start'),
+        clearStoredImagePaths,
+        clearAllSessions,
+        clearAllPendingCallbacks,
+        clearTungstenUsageCaches: () => {
+            if (process.env.USER_TYPE === 'ant') {
+                void import('../../../tools/TungstenTool/TungstenTool.js').then(({ clearSessionsWithTungstenUsage, resetInitializationState }) => {
+                    clearSessionsWithTungstenUsage();
+                    resetInitializationState();
+                });
+            }
+        },
+        clearAttributionCaches: () => {
+            if (feature('COMMIT_ATTRIBUTION')) {
+                void import('../../../utils/attributionHooks.js').then(({ clearAttributionCaches }) => clearAttributionCaches());
+            }
+        },
+        clearRepositoryCaches,
+        clearCommandPrefixCaches,
+        clearAllDumpState,
+        clearInvokedSkills,
+        clearResolveGitDirCache,
+        clearDynamicSkills,
+        resetAllLspDiagnosticState: resetAllLSPDiagnosticState,
+        clearTrackedMagicDocs,
+        clearSessionEnvVars,
+        clearWebFetchCache: () => {
+            void import('../../../tools/WebFetchTool/utils.js').then(({ clearWebFetchCache }) => clearWebFetchCache());
+        },
+        clearToolSearchDescriptionCache: () => {
+            void import('../../../tools/ToolSearchTool/ToolSearchTool.js').then(({ clearToolSearchDescriptionCache }) => clearToolSearchDescriptionCache());
+        },
+        clearAgentDefinitionsCache: () => {
+            void import('../../../tools/AgentTool/loadAgentsDir.js').then(({ clearAgentDefinitionsCache }) => clearAgentDefinitionsCache());
+        },
+        clearSkillPromptCache: () => {
+            void import('../../../tools/SkillTool/prompt.js').then(({ clearPromptCache }) => clearPromptCache());
+        },
+    };
+}
+function buildPreservedTaskSnapshot(getAppState) {
+    const preservedAgentIds = new Set();
+    const preservedLocalAgentTaskIds = [];
+    if (!getAppState)
+        return { preservedAgentIds, preservedLocalAgentTaskIds };
+    for (const task of Object.values(getAppState().tasks)) {
+        if ('isBackgrounded' in task && task.isBackgrounded === false)
+            continue;
+        if (isLocalAgentTask(task)) {
+            preservedAgentIds.add(task.agentId);
+            if (task.status === 'running')
+                preservedLocalAgentTaskIds.push(task.id);
+            continue;
+        }
+        if (isInProcessTeammateTask(task))
+            preservedAgentIds.add(task.identity.agentId);
+    }
+    return { preservedAgentIds, preservedLocalAgentTaskIds };
+}
+export function createClearConversationInput() {
+    return {
+        hasProactiveFeature: feature('PROACTIVE') || feature('KAIROS'),
+        hasCoordinatorModeFeature: feature('COORDINATOR_MODE'),
+        lastRequestId: getLastMainRequestId(),
+        originalCwd: getOriginalCwd(),
+        userType: process.env.USER_TYPE,
+        envSessionId: process.env.CLAUDE_CODE_SESSION_ID,
+        shouldUpdateEnvSessionId: true,
+    };
+}
+export function logCacheEvictionHintEvent(lastRequestId) {
+    logEvent('tengu_cache_eviction_hint', {
+        scope: 'conversation_clear',
+        last_request_id: lastRequestId,
+    });
+}
+export function createClearConversationDeps(args) {
+    let preservedLocalAgentTasks = [];
+    return {
+        getSessionEndHookTimeoutMs,
+        executeSessionEndHooks: async ({ timeoutMs }) => {
+            await executeSessionEndHooks('clear', {
+                getAppState: args.getAppState,
+                setAppState: args.setAppState,
+                signal: AbortSignal.timeout(timeoutMs),
+                timeoutMs,
+            });
+        },
+        logCacheEvictionHint: args.logCacheEvictionHint,
+        setMessagesEmpty: () => args.setMessages(() => []),
+        setContextBlocked: blocked => {
+            void import('../../proactive/index.js').then(({ setContextBlocked }) => {
+                setContextBlocked(blocked);
+            });
+        },
+        setConversationId: args.setConversationId,
+        clearSessionCaches: args.clearSessionCaches,
+        setCwd,
+        clearReadFileState: () => args.readFileState.clear(),
+        clearDiscoveredSkillNames: () => args.discoveredSkillNames?.clear(),
+        clearLoadedNestedMemoryPaths: () => args.loadedNestedMemoryPaths?.clear(),
+        getPreservedTaskSnapshot: () => {
+            const snapshot = buildPreservedTaskSnapshot(args.getAppState);
+            if (args.getAppState) {
+                preservedLocalAgentTasks = Object.values(args.getAppState().tasks).filter(task => isLocalAgentTask(task) &&
+                    snapshot.preservedLocalAgentTaskIds.includes(task.id));
+            }
+            return snapshot;
+        },
+        clearAppState: ({ preservedTaskIds }) => {
+            if (!args.setAppState)
+                return;
+            args.setAppState(prev => {
+                const nextTasks = {};
+                for (const [taskId, task] of Object.entries(prev.tasks)) {
+                    if (preservedTaskIds.has(taskId)) {
+                        nextTasks[taskId] = task;
+                        continue;
+                    }
+                    if (!('isBackgrounded' in task) || task.isBackgrounded !== false) {
+                        nextTasks[taskId] = task;
+                        continue;
+                    }
+                    try {
+                        if (task.status === 'running') {
+                            if (isLocalShellTask(task)) {
+                                task.shellCommand?.kill();
+                                task.shellCommand?.cleanup();
+                                if (task.cleanupTimeoutId)
+                                    clearTimeout(task.cleanupTimeoutId);
+                            }
+                            if ('abortController' in task)
+                                task.abortController?.abort();
+                            if ('unregisterCleanup' in task)
+                                task.unregisterCleanup?.();
+                        }
+                    }
+                    catch (error) {
+                        logError(error);
+                    }
+                    void evictTaskOutput(taskId);
+                }
+                return {
+                    ...prev,
+                    tasks: nextTasks,
+                    attribution: createEmptyAttributionState(),
+                    standaloneAgentContext: undefined,
+                    fileHistory: {
+                        snapshots: [],
+                        trackedFiles: new Set(),
+                        snapshotSequence: 0,
+                    },
+                    mcp: {
+                        clients: [],
+                        tools: [],
+                        commands: [],
+                        resources: {},
+                        pluginReconnectKey: prev.mcp.pluginReconnectKey,
+                    },
+                };
+            });
+        },
+        clearPlanSlugs: clearAllPlanSlugs,
+        clearSessionMetadata,
+        regenerateSessionId: () => regenerateSessionId({ setCurrentAsParent: true }),
+        getSessionId,
+        resetSessionFilePointer,
+        refreshRunningTaskOutputLinks: () => {
+            for (const task of preservedLocalAgentTasks) {
+                if (task.status !== 'running')
+                    continue;
+                void initTaskOutputAsSymlink(task.id, getAgentTranscriptPath(asAgentId(task.agentId)));
+            }
+        },
+        saveMode: () => {
+            void import('../../../coordinator/coordinatorMode.js').then(({ isCoordinatorMode }) => {
+                void import('../../../utils/sessionStorage.js').then(({ saveMode }) => {
+                    saveMode(isCoordinatorMode() ? 'coordinator' : 'normal');
+                });
+            });
+        },
+        saveWorktreeState: () => {
+            const worktreeSession = getCurrentWorktreeSession();
+            if (worktreeSession)
+                saveWorktreeState(worktreeSession);
+        },
+        processSessionStartHooks: () => processSessionStartHooks('clear'),
+        setMessagesToHookMessages: hookMessages => {
+            if (hookMessages.length > 0) {
+                args.setMessages(() => hookMessages);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,5 @@
+import { getSessionId } from '../../../bootstrap/state.js';
+import { AGENT_COLORS, } from '../../../tools/AgentTool/agentColorManager.js';
+import { getTranscriptPath, saveAgentColor } from '../../../utils/sessionStorage.js';
+import { isTeammate } from '../../../utils/teammate.js';
+export { AGENT_COLORS, getSessionId, getTranscriptPath, isTeammate, saveAgentColor, };

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

@@ -0,0 +1,11 @@
+import { createRequire } from 'module';
+import { getSystemContext, getUserContext } from '../../../context.js';
+import { logError } from '../../../utils/log.js';
+import { getMessagesAfterCompactBoundary } from '../../../utils/messages.js';
+import { getUpgradeMessage } from '../../../utils/model/contextWindowUpgradeCheck.js';
+import { buildEffectiveSystemPrompt, } from '../../../utils/systemPrompt.js';
+const require = createRequire(import.meta.url);
+export { buildEffectiveSystemPrompt, getMessagesAfterCompactBoundary, getSystemContext, getUpgradeMessage, getUserContext, logError, };
+export const reactiveCompact = process.versions.bun
+    ? require('../../../services/compact/reactiveCompact.js')
+    : null;

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

@@ -0,0 +1,9 @@
+export { notifyCompaction } from '../../../services/api/promptCacheBreakDetection.js';
+export { compactConversation, ERROR_MESSAGE_INCOMPLETE_RESPONSE, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES, ERROR_MESSAGE_USER_ABORT, mergeHookInstructions, } from '../../../services/compact/compact.js';
+export { suppressCompactWarning } from '../../../services/compact/compactWarningState.js';
+export { microcompactMessages } from '../../../services/compact/microCompact.js';
+export { runPostCompactCleanup } from '../../../services/compact/postCompactCleanup.js';
+export { trySessionMemoryCompaction } from '../../../services/compact/sessionMemoryCompact.js';
+export { setLastSummarizedMessageId } from '../../../services/SessionMemory/sessionMemoryUtils.js';
+export { hasExactErrorMessage } from '../../../utils/errors.js';
+export { executePreCompactHooks } from '../../../utils/hooks.js';

package/dist/src/core/session/legacy/contextCliAdapter.js

@@ -0,0 +1,6 @@
+export { microcompactMessages } from '../../../services/compact/microCompact.js';
+export { analyzeContextUsage } from '../../../utils/analyzeContext.js';
+export { formatTokens } from '../../../utils/format.js';
+export { getMessagesAfterCompactBoundary } from '../../../utils/messages.js';
+export { getSourceDisplayName } from '../../../utils/settings/constants.js';
+export { plural } from '../../../utils/stringUtils.js';

package/dist/src/core/session/legacy/contextCollapseIndex.js

@@ -0,0 +1 @@
+export * from '../../../services/contextCollapse/index.js';

package/dist/src/core/session/legacy/contextCollapseOperations.js

@@ -0,0 +1 @@
+export * from '../../../services/contextCollapse/operations.js';

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

@@ -0,0 +1,2 @@
+import { renderToAnsiString } from '../../../utils/staticRender.js';
+export { renderToAnsiString };

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

@@ -0,0 +1,5 @@
+import { logEvent } from '../../../services/analytics/index.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../../utils/config.js';
+import { extractTextContent, stripPromptXMLTags } from '../../../utils/messages.js';
+import { countCharInString } from '../../../utils/stringUtils.js';
+export { countCharInString, extractTextContent, getGlobalConfig, logEvent, saveGlobalConfig, stripPromptXMLTags, };

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

@@ -0,0 +1,4 @@
+import { isBgSession } from '../../../utils/concurrentSessions.js';
+import { gracefulShutdown } from '../../../utils/gracefulShutdown.js';
+import { getCurrentWorktreeSession } from '../../../utils/worktree.js';
+export { isBgSession, gracefulShutdown, getCurrentWorktreeSession };

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

@@ -0,0 +1,4 @@
+import { getCwd } from '../../../utils/cwd.js';
+import { renderMessagesToPlainText } from '../../../utils/exportRenderer.js';
+import { writeFileSync_DEPRECATED } from '../../../utils/slowOperations.js';
+export { getCwd, renderMessagesToPlainText, writeFileSync_DEPRECATED };

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

@@ -0,0 +1,3 @@
+import { getCwd } from '../../../utils/cwd.js';
+import { cacheKeys } from '../../../utils/fileStateCache.js';
+export { getCwd, cacheKeys };

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

@@ -0,0 +1,19 @@
+import { queryHaiku } from '../../../services/api/claude.js';
+import { logForDebugging } from '../../../utils/debug.js';
+import { errorMessage } from '../../../utils/errors.js';
+import { safeParseJSON } from '../../../utils/json.js';
+import { extractTextContent } from '../../../utils/messages.js';
+import { extractConversationText } from '../../../utils/sessionTitle.js';
+import { asSystemPrompt } from '../../../utils/systemPromptType.js';
+export const cliGenerateSessionNameDeps = {
+    queryHaiku,
+    asSystemPrompt,
+    extractTextContent,
+    extractConversationText,
+    safeParseJSON,
+    logDebugError: error => {
+        logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, {
+            level: 'error',
+        });
+    },
+};

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

@@ -0,0 +1,2 @@
+import { performHeapDump } from '../../../utils/heapDumpService.js';
+export { performHeapDump };

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

@@ -0,0 +1,3 @@
+import { getErrnoCode } from '../../../utils/errors.js';
+import { editFileInEditor } from '../../../utils/promptEditor.js';
+export { getErrnoCode, editFileInEditor };

package/dist/src/core/session/legacy/memoryCliAdapter.impl.js

@@ -0,0 +1,26 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { getRelativeMemoryPath } from '../../../components/memory/MemoryUpdateNotification.js';
+import { clearMemoryFileCaches, getMemoryFiles } from '../../../utils/claudemd.js';
+import { getClaudeConfigHomeDir } from '../../../utils/envUtils.js';
+import { getErrnoCode } from '../../../utils/errors.js';
+import { logError } from '../../../utils/log.js';
+import { editFileInEditor } from '../../../utils/promptEditor.js';
+export function createMemoryPrimeDepsCli() {
+    return {
+        clearMemoryFileCaches,
+        getMemoryFiles,
+    };
+}
+export function createMemoryOpenDepsCli() {
+    return {
+        getClaudeConfigHomeDir,
+        mkdir,
+        writeFile,
+        getErrnoCode,
+        editFileInEditor,
+        getRelativeMemoryPath,
+        getVisualEnv: () => process.env.VISUAL,
+        getEditorEnv: () => process.env.EDITOR,
+        logError,
+    };
+}

package/dist/src/core/session/legacy/planCliAdapter.impl.js

@@ -0,0 +1,32 @@
+import { handlePlanModeTransition } from '../../../bootstrap/state.js';
+import { getExternalEditor } from '../../../utils/editor.js';
+import { toIDEDisplayName } from '../../../utils/ide.js';
+import { applyPermissionUpdate } from '../../../utils/permissions/PermissionUpdate.js';
+import { prepareContextForPlanMode } from '../../../utils/permissions/permissionSetup.js';
+import { getPlan, getPlanFilePath } from '../../../utils/plans.js';
+import { editFileInEditor } from '../../../utils/promptEditor.js';
+import { renderToString } from '../../../utils/staticRender.js';
+export function applyPlanModeTransitionCli(input) {
+    handlePlanModeTransition(input.currentMode, 'plan');
+    input.setAppState(prev => ({
+        ...prev,
+        toolPermissionContext: applyPermissionUpdate(prepareContextForPlanMode(prev.toolPermissionContext), { type: 'setMode', mode: 'plan', destination: 'session' }),
+    }));
+}
+export function getPlanDisplayDataCli() {
+    const planContent = getPlan();
+    const planPath = getPlanFilePath();
+    if (!planContent) {
+        return null;
+    }
+    const editor = getExternalEditor();
+    return {
+        planContent,
+        planPath,
+        editorName: editor ? toIDEDisplayName(editor) : undefined,
+    };
+}
+export async function openPlanInEditorCli(planPath) {
+    return editFileInEditor(planPath);
+}
+export { renderToString as renderPlanDisplayToStringCli };

package/dist/src/core/session/legacy/releaseNotesCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { CHANGELOG_URL, fetchAndStoreChangelog, getAllReleaseNotes, getStoredChangelog, } from '../../../utils/releaseNotes.js';
+import { translateReleaseNoteToSpanish } from '../../../utils/releaseNoteTranslations.js';
+export { CHANGELOG_URL, fetchAndStoreChangelog, getAllReleaseNotes, getStoredChangelog, translateReleaseNoteToSpanish, };

package/dist/src/core/session/legacy/renameCliAdapter.impl.js

@@ -0,0 +1,51 @@
+import { getBridgeBaseUrlOverride, getBridgeTokenOverride, } from '../../../bridge/bridgeConfig.js';
+import { getSessionId } from '../../../bootstrap/state.js';
+import { getTranscriptPath, saveAgentName, saveCustomTitle } from '../../../utils/sessionStorage.js';
+import { generateSessionName } from '../../../commands/rename/generateSessionName.js';
+import { isTeammate } from '../../../utils/teammate.js';
+import { getMessagesAfterCompactBoundary } from '../../../utils/messages.js';
+export function isTeammateCli() {
+    return isTeammate();
+}
+export function getBridgeSessionIdCli(context) {
+    return context.getAppState().replBridgeSessionId;
+}
+export function createRenameCoreInputCli(context, args) {
+    return {
+        args,
+        messages: getMessagesAfterCompactBoundary(context.messages),
+        signal: context.abortController.signal,
+        isTeammate: isTeammateCli(),
+        bridgeSessionId: getBridgeSessionIdCli(context),
+    };
+}
+export function createRenameCoreDepsCli(context) {
+    return {
+        generateSessionName,
+        saveCustomTitle: async (name) => {
+            const sessionId = getSessionId();
+            await saveCustomTitle(sessionId, name, getTranscriptPath());
+        },
+        saveAgentName: async (name) => {
+            const sessionId = getSessionId();
+            await saveAgentName(sessionId, name, getTranscriptPath());
+        },
+        updateBridgeSessionTitle: async (bridgeSessionId, title) => {
+            const tokenOverride = getBridgeTokenOverride();
+            const { updateBridgeSessionTitle } = await import('../../../bridge/createSession.js');
+            await updateBridgeSessionTitle(bridgeSessionId, title, {
+                baseUrl: getBridgeBaseUrlOverride(),
+                getAccessToken: tokenOverride ? () => tokenOverride : undefined,
+            });
+        },
+        setStandaloneAgentName: name => {
+            context.setAppState(prev => ({
+                ...prev,
+                standaloneAgentContext: {
+                    ...prev.standaloneAgentContext,
+                    name,
+                },
+            }));
+        },
+    };
+}

package/dist/src/core/session/legacy/resumeCliAdapter.impl.js

@@ -0,0 +1,96 @@
+import { getOriginalCwd, getSessionId } from '../../../bootstrap/state.js';
+import { useIsInsideModal } from '../../../context/modalContext.js';
+import { useTerminalSize } from '../../../hooks/useTerminalSize.js';
+import { setClipboard } from '../../../ink/termio/osc.js';
+import { agenticSessionSearch } from '../../../utils/agenticSessionSearch.js';
+import { checkCrossProjectResume } from '../../../utils/crossProjectResume.js';
+import { logError } from '../../../utils/log.js';
+import { getWorktreePaths } from '../../../utils/getWorktreePaths.js';
+import { getLastSessionLog, getSessionIdFromLog, isCustomTitleEnabled, isLiteLog, loadAllProjectsMessageLogs, loadFullLog, loadSameRepoMessageLogs, searchSessionsByCustomTitle, } from '../../../utils/sessionStorage.js';
+import { filterResumableSessionsCore, findSessionInLogsByIdCore } from '../resumeCore.js';
+import { resumeHelpMessageCore } from '../resumeCore.js';
+export async function getResumeWorktreePathsCli() {
+    return getWorktreePaths(getOriginalCwd());
+}
+export async function loadResumableLogsCli(input) {
+    const allLogs = input.allProjects
+        ? await loadAllProjectsMessageLogs()
+        : await loadSameRepoMessageLogs(input.paths);
+    return filterResumableSessionsCore(allLogs, getSessionId());
+}
+export async function resolveResumeSelectionCli(input) {
+    const sessionId = getSessionIdFromLog(input.log);
+    if (!sessionId) {
+        throw new Error('Failed to resume conversation');
+    }
+    const fullLog = isLiteLog(input.log) ? await loadFullLog(input.log) : input.log;
+    const crossProjectCheck = checkCrossProjectResume(fullLog, input.showAllProjects, input.worktreePaths);
+    if (crossProjectCheck.isCrossProject && !crossProjectCheck.isSameRepoWorktree) {
+        return { type: 'crossProject', command: crossProjectCheck.command };
+    }
+    return { type: 'resume', sessionId, log: fullLog };
+}
+export async function resolveResumeArgCli(input) {
+    const logs = await loadSameRepoMessageLogs(input.worktreePaths);
+    if (logs.length === 0)
+        return { type: 'empty' };
+    const matchById = findSessionInLogsByIdCore(input.arg, logs);
+    if (matchById) {
+        const fullLog = isLiteLog(matchById.log)
+            ? await loadFullLog(matchById.log)
+            : matchById.log;
+        return {
+            type: 'session',
+            sessionId: matchById.sessionId,
+            log: fullLog,
+            entrypoint: 'slash_command_session_id',
+        };
+    }
+    const directLog = await getLastSessionLog(input.arg);
+    if (directLog) {
+        return {
+            type: 'session',
+            sessionId: input.arg,
+            log: directLog,
+            entrypoint: 'slash_command_session_id',
+        };
+    }
+    if (isCustomTitleEnabled()) {
+        const titleMatches = await searchSessionsByCustomTitle(input.arg, { exact: true });
+        if (titleMatches.length === 1) {
+            const log = titleMatches[0];
+            const sessionId = getSessionIdFromLog(log);
+            if (sessionId) {
+                const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+                return {
+                    type: 'session',
+                    sessionId,
+                    log: fullLog,
+                    entrypoint: 'slash_command_title',
+                };
+            }
+        }
+        if (titleMatches.length > 1) {
+            return { type: 'multipleTitleMatches', count: titleMatches.length };
+        }
+    }
+    return { type: 'notFound' };
+}
+export function useResumeTerminalRowsCli() {
+    return useTerminalSize().rows;
+}
+export function useResumeInsideModalCli() {
+    return useIsInsideModal();
+}
+export function onAgenticSearchCli() {
+    return agenticSessionSearch;
+}
+export function logResumeErrorCli(error) {
+    logError(error);
+}
+export async function copyResumeCommandToClipboardCli(command) {
+    return setClipboard(command);
+}
+export function formatResumeHelpCli(result) {
+    return resumeHelpMessageCore(result);
+}

package/dist/src/core/session/legacy/resumeCommandCliAdapter.impl.js

@@ -0,0 +1,7 @@
+import { agenticSessionSearch } from '../../../utils/agenticSessionSearch.js';
+import { logError } from '../../../utils/log.js';
+export const resumeAgenticSessionSearchCli = agenticSessionSearch;
+export function formatResumeFailureMessageCli(error) {
+    logError(error);
+    return `Failed to resume: ${error.message}`;
+}

package/dist/src/core/session/legacy/resumeCoreCliAdapter.js

@@ -0,0 +1,2 @@
+export { getSessionIdFromLog } from '../../../utils/sessionStorage.js';
+export { validateUuid } from '../../../utils/uuid.js';

package/dist/src/core/session/legacy/resumenCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { parseArguments } from '../../../utils/argumentSubstitution.js';
+import { listOrchestrationRuns } from '../../../utils/orchestration/store/index.js';
+export { parseArguments, listOrchestrationRuns };

package/dist/src/core/session/legacy/sessionCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { useAppState } from '../../../state/AppState.js';
+import { logForDebugging } from '../../../utils/debug.js';
+export { useAppState, logForDebugging };