@greppleai/grip 0.1.5 → 0.1.7

package/dist/core/agent-session.js

@@ -15,12 +15,15 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { readFile as fsReadFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, posix, sep, win32 } from "node:path";
 import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, validateToolArguments, } from "@greppleai/grip-ai";
 import { Text } from "@greppleai/grip-tui";
 import { Type } from "typebox";
+import { keyText } from "../modes/interactive/components/keybinding-hints.js";
 import { theme } from "../modes/interactive/theme/theme.js";
+import { getSandboxDirectoryCompletions } from "../utils/directory-completions.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { canonicalizePath, resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
@@ -32,6 +35,7 @@ import { appendCompressionDetectionEvent, readCompressionDetectionLedger, } from
 import { CompressionDetector, } from "./compaction/compression-detector.js";
 import { COMPRESSION_ECONOMICS_ENTRY_TYPE, COMPRESSION_SAVINGS_SNAPSHOT_TYPE, createCompressionSavingsSnapshot, estimateCompressionEconomics, } from "./compaction/compression-economics.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { execCommand } from "./exec.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, emitSessionShutdownEvent, } from "./extensions/runner.js";
@@ -55,6 +59,7 @@ import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createCompressContextToolDefinition, getCompressibleEntries, getSuggestedCompressionRangeError, isValidSuggestedCompressionRange, } from "./tools/compress-context.js";
 import { DeferredRemoteToolOperations, LocalToolOperations, } from "./tools/operations.js";
+import { getTextOutput } from "./tools/render-utils.js";
 import { createSessionEntryGetToolDefinition, createSessionSearchToolDefinition } from "./tools/session-history.js";
 import { createCreateSubagentToolDefinition, createSubagentRunsToolDefinition, createSubagentToolDefinition, formatSubagentModelCatalog, } from "./tools/subagent.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
@@ -63,7 +68,7 @@ import { WORKSPACE_TOOL_NAMES, WorkspaceToolHost } from "./tools/workspace-tool-
 // ============================================================================
 // Skill Block Parsing
 // ============================================================================
-const CORE_DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write", "websearch"];
+const CORE_DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write", "websearch", "load_skill"];
 const SESSION_HISTORY_TOOL_NAMES = ["session_search", "session_entry_get"];
 export const SUBAGENT_TOOL_NAMES = ["subagent", "subagent_runs", "create_subagent"];
 export const DEFAULT_ACTIVE_TOOL_NAMES = [...CORE_DEFAULT_TOOL_NAMES, ...SESSION_HISTORY_TOOL_NAMES];
@@ -383,127 +388,111 @@ function extractJsonCandidates(text) {
 // ============================================================================
 // AgentSession Class
 // ============================================================================
+function isWithinSandboxMount(directory, root, flavor) {
+    const paths = flavor === "windows" ? win32 : posix;
+    const relativePath = paths.relative(root, directory);
+    return relativePath !== ".." && !relativePath.startsWith(`..${paths.sep}`) && !paths.isAbsolute(relativePath);
+}
+function hasValidHostProcessApproval(options) {
+    return (typeof options?.question === "string" &&
+        !!options.question.trim() &&
+        (options.explanation === undefined || (typeof options.explanation === "string" && !!options.explanation.trim())));
+}
 export class AgentSession {
-    agent;
-    session;
-    settingsManager;
-    _scopedModels;
-    // Event subscription state
-    _unsubscribeAgent;
-    _eventListeners = [];
-    _disposePromise;
-    _shutdownPreparationPromise;
-    _disposed = false;
-    /** Tracks pending steering messages for UI display. Removed when delivered. */
-    _steeringMessages = [];
-    /** Tracks pending follow-up messages for UI display. Removed when delivered. */
-    _followUpMessages = [];
-    /** Messages queued to be included with the next user prompt as context ("asides"). */
-    _pendingNextTurnMessages = [];
-    // Compaction state
-    _compactionInFlight;
-    _compactionAbortController = undefined;
-    _autoCompactionAbortController = undefined;
-    _extensionCompactionQueue = [];
-    _extensionCompactionTimer = undefined;
-    _extensionCompactionActivity;
-    _extensionCompactionRunning = false;
-    _overflowRecoveryAttempted = false;
-    // Branch summarization state
-    _branchSummaryAbortController = undefined;
-    // Retry state
-    _retryAbortController = undefined;
-    _retryAttempt = 0;
-    // Bash execution state
-    _bashAbortControllers = new Set();
-    _pendingBashMessages = [];
-    // Extension system
-    _extensionRunner;
-    _extensionLspOwnership = new WeakMap();
-    _turnIndex = 0;
-    _resourceLoader;
-    _customTools;
-    _baseToolDefinitions = new Map();
-    _workspaceToolHost;
-    _retiredWorkspaceToolHosts = [];
-    _cwd;
-    _extensionRunnerRef;
-    _initialActiveToolNames;
-    _enableLspTools;
-    _allowedToolNames;
-    _excludedToolNames;
-    _baseToolsOverride;
-    _toolOperations;
-    _runtimeToolOperations;
-    _subagentRunner;
-    _subagentRunRegistry;
-    _subagentConfigRegistry;
-    _trustProjectAgents;
-    _localResourceToolOperations;
-    _sandboxToolOperations;
-    _preSandboxToolOperations;
-    _lspRuntimeState;
-    _lspConfiguration;
-    _lspConnectionFactories;
-    _resolveLspConfiguration;
-    _onLspConfigurationDiagnostics;
-    _runtimeLifecycleQueue = Promise.resolve();
-    _sandboxTransitionQueue = Promise.resolve();
-    _runtimeLifecycleContext = new AsyncLocalStorage();
-    _activities = new Set();
-    _activityGeneration = 0;
-    _activeCycle = false;
-    _settlementScheduled = false;
-    _settlementRunning = false;
-    _idleWaiters = new Set();
-    _barrierOwnerContext = new AsyncLocalStorage();
-    _sessionStartEvent;
-    _extensionUIContext;
-    _extensionCommandContextActions;
-    _extensionAbortHandler;
-    _extensionShutdownHandler;
-    _extensionErrorListener;
-    _extensionErrorUnsubscriber;
-    _loadedHooks;
-    _resolveHooks;
-    _hooksEnabled = true;
-    _onHookDiagnostic;
-    _hookExecutionListeners = new Set();
-    _hookExecutionActivityListeners = new Set();
-    _hookRunOptions;
-    _hookAbortController = new AbortController();
-    _hookSessionStartPromise;
-    _hookSessionStartTerminationReason;
-    _pendingHookSessionStartContext;
-    _hookSessionEnded = false;
-    _activePromptId;
-    _stopHookContinuations = 0;
-    _stopHookProgress;
-    _queuedPromptIds = new Map();
-    _toolStartedAt = new Map();
-    _preToolHookContext = new Map();
-    _compressionDetector;
-    _contextCompressionEnabledOverride;
-    _compressionDetectionEnabled = process.env.GRIP_CONTEXT_COMPRESSION_DETECTION === "1";
-    _agentRunEnding = false;
-    _waitingForDetectorAtRequest = false;
-    _pendingContextCompression;
-    _stateCompressionApplied = false;
-    // Model registry for API key resolution
-    _modelRegistry;
-    // Tool registry for extension getTools/setTools
-    _toolRegistry = new Map();
-    _toolDefinitions = new Map();
-    _sessionTools = new Map();
-    _sessionSkills = new Map();
-    _sessionRules = new Map();
-    _toolPromptSnippets = new Map();
-    _toolPromptGuidelines = new Map();
-    // Base system prompt (without extension appends) - used to apply fresh appends each turn
-    _baseSystemPrompt = "";
-    _baseSystemPromptOptions;
-    _systemPromptOverride;
     constructor(config) {
+        this._eventListeners = [];
+        this._disposed = false;
+        /** Tracks pending steering messages for UI display. Removed when delivered. */
+        this._steeringMessages = [];
+        /** Tracks pending follow-up messages for UI display. Removed when delivered. */
+        this._followUpMessages = [];
+        /** Messages queued to be included with the next user prompt as context ("asides"). */
+        this._pendingNextTurnMessages = [];
+        this._compactionAbortController = undefined;
+        this._autoCompactionAbortController = undefined;
+        this._extensionCompactionQueue = [];
+        this._extensionCompactionTimer = undefined;
+        this._extensionCompactionRunning = false;
+        this._overflowRecoveryAttempted = false;
+        // Branch summarization state
+        this._branchSummaryAbortController = undefined;
+        // Retry state
+        this._retryAbortController = undefined;
+        this._retryAttempt = 0;
+        // Bash execution state
+        this._bashAbortControllers = new Set();
+        this._pendingBashMessages = [];
+        this._extensionLspOwnership = new WeakMap();
+        this._turnIndex = 0;
+        this._baseToolDefinitions = new Map();
+        this._retiredWorkspaceToolHosts = [];
+        this._runtimeLifecycleQueue = Promise.resolve();
+        this._sandboxTransitionQueue = Promise.resolve();
+        this._runtimeLifecycleContext = new AsyncLocalStorage();
+        this._activities = new Set();
+        this._activityGeneration = 0;
+        this._activeCycle = false;
+        this._hostCommandApprovalQueue = Promise.resolve();
+        this._settlementScheduled = false;
+        this._settlementRunning = false;
+        this._idleWaiters = new Set();
+        this._barrierOwnerContext = new AsyncLocalStorage();
+        this._hooksEnabled = true;
+        this._hookExecutionListeners = new Set();
+        this._hookExecutionActivityListeners = new Set();
+        this._hookAbortController = new AbortController();
+        this._hookSessionEnded = false;
+        this._stopHookContinuations = 0;
+        this._queuedPromptIds = new Map();
+        this._toolStartedAt = new Map();
+        this._preToolHookContext = new Map();
+        this._compressionDetectionEnabled = process.env.GRIP_CONTEXT_COMPRESSION_DETECTION === "1";
+        this._agentRunEnding = false;
+        this._waitingForDetectorAtRequest = false;
+        this._stateCompressionApplied = false;
+        // Tool registry for extension getTools/setTools
+        this._toolRegistry = new Map();
+        this._toolDefinitions = new Map();
+        this._sessionTools = new Map();
+        this._sessionSkills = new Map();
+        this._sessionRules = new Map();
+        this._toolPromptSnippets = new Map();
+        this._toolPromptGuidelines = new Map();
+        // Base system prompt (without extension appends) - used to apply fresh appends each turn
+        this._baseSystemPrompt = "";
+        // Track last assistant message for auto-compaction check
+        this._lastAssistantMessage = undefined;
+        /** Internal handler for agent events - shared by subscribe and reconnect */
+        this._handleAgentEvent = async (event) => {
+            if (event.type === "agent_start")
+                this._agentRunEnding = false;
+            // afterToolCall can be skipped when a prepared call is aborted. Never retain per-run tool state.
+            if (event.type === "agent_end") {
+                this._agentRunEnding = true;
+                this._toolStartedAt.clear();
+                this._preToolHookContext.clear();
+                this._pendingContextCompression = undefined;
+            }
+            this._consumeStartedQueuedMessage(event);
+            // Extensions observe the event before public session listeners.
+            await this._runAsyncBarrierCallback(`extension ${event.type} handler`, () => this._emitExtensionEvent(event));
+            this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
+            if (event.type === "agent_end") {
+                const entries = this.session.getEntries();
+                const ledger = readUsageLedger(entries);
+                const lastEntry = entries.at(-1);
+                if (ledger.checkpointId && !(lastEntry?.type === "custom" && lastEntry.customType === USAGE_LEDGER_ENTRY_TYPE))
+                    this.session.appendCustomEntry(USAGE_LEDGER_ENTRY_TYPE, ledger);
+                this._scheduleExtensionCompactions();
+                if (!this._disposed && this.compressionDetectionEnabled)
+                    this._compressionDetector.check(this.getContextUsage()?.percent, this.agent.state.messages, this._buildCurrentAgentContext().systemPrompt, getCompressibleEntries(this.session, ""));
+            }
+            if (event.type === "message_end") {
+                this._persistCompletedMessage(event.message);
+                this._applyPendingContextCompression(event.message);
+                this._updateRetryStateAfterAssistantMessage(event.message);
+            }
+        };
         this.agent = config.agent;
         this.session = config.session;
         this.settingsManager = config.settingsManager;
@@ -620,6 +609,11 @@ export class AgentSession {
     getToolBackendInfo() {
         return this.getToolOperations().getBackendInfo?.() ?? { type: "local", cwd: this._cwd };
     }
+    /** Whether the current session is using a live, session-owned sandbox connection. */
+    isSandbox() {
+        const operations = this._sandboxToolOperations;
+        return !!operations && operations === this._toolOperations && !operations.isDisconnected();
+    }
     supportsDirectoryChange() {
         return this._toolOperations === undefined && this.getToolBackendInfo().type === "local";
     }
@@ -690,7 +684,39 @@ export class AgentSession {
         }));
     }
     async activateSandboxDaemon(options) {
-        return this._runActivity("sandbox daemon activation", () => this._enqueueSandboxTransition(() => this._activateSessionRemoteOperations(options.expectedCwd, (operations) => operations.configureRemote(options.url, { token: options.token, expectedCwd: options.expectedCwd }))));
+        return this._runActivity("sandbox daemon activation", () => this._enqueueSandboxTransition(() => this._activateSessionRemoteOperations(options.expectedCwd, (operations) => operations.configureRemote(options.url, {
+            token: options.token,
+            expectedCwd: options.expectedCwd,
+            hostWorkspaceRoot: options.hostWorkspaceRoot,
+        }))));
+    }
+    /** Complete only directories available inside the connected sandbox's mounted workspace. */
+    async getSandboxDirectoryCompletions(prefix) {
+        const operations = this._sandboxToolOperations;
+        const backend = operations?.getBackendInfo();
+        if (!operations || operations !== this._toolOperations || backend?.type !== "remote" || !backend.configured)
+            return [];
+        return getSandboxDirectoryCompletions(prefix, operations.cwd, backend.workspace.pathFlavor, operations);
+    }
+    /** Change only the connected sandbox's working directory, never the host session or mount. */
+    async changeSandboxWorkingDirectory(target) {
+        const operations = this._sandboxToolOperations;
+        const backend = operations?.getBackendInfo();
+        if (!operations || operations !== this._toolOperations || backend?.type !== "remote" || !backend.configured) {
+            throw new Error("No connected sandbox is active");
+        }
+        const paths = backend.workspace.pathFlavor === "windows" ? win32 : posix;
+        const candidate = paths.resolve(operations.cwd, target);
+        if (!isWithinSandboxMount(candidate, backend.workspace.root, backend.workspace.pathFlavor)) {
+            throw new Error(`Directory is outside the mounted workspace: ${target}`);
+        }
+        const directory = await operations.resolveWorkspaceDirectory(candidate);
+        if (!isWithinSandboxMount(directory, backend.workspace.root, backend.workspace.pathFlavor)) {
+            throw new Error(`Directory is outside the mounted workspace: ${target}`);
+        }
+        operations.cwd = directory;
+        this._refreshBaseSystemPrompt();
+        return directory;
     }
     async _activateSessionRemoteOperations(expectedCwd, configure) {
         if (this._sandboxToolOperations)
@@ -1538,8 +1564,6 @@ export class AgentSession {
             followUp: [...this._followUpMessages],
         });
     }
-    // Track last assistant message for auto-compaction check
-    _lastAssistantMessage = undefined;
     _consumeStartedQueuedMessage(event) {
         if (event.type !== "message_start" || event.message.role !== "user")
             return;
@@ -1665,37 +1689,6 @@ export class AgentSession {
         });
         this._retryAttempt = 0;
     }
-    /** Internal handler for agent events - shared by subscribe and reconnect */
-    _handleAgentEvent = async (event) => {
-        if (event.type === "agent_start")
-            this._agentRunEnding = false;
-        // afterToolCall can be skipped when a prepared call is aborted. Never retain per-run tool state.
-        if (event.type === "agent_end") {
-            this._agentRunEnding = true;
-            this._toolStartedAt.clear();
-            this._preToolHookContext.clear();
-            this._pendingContextCompression = undefined;
-        }
-        this._consumeStartedQueuedMessage(event);
-        // Extensions observe the event before public session listeners.
-        await this._runAsyncBarrierCallback(`extension ${event.type} handler`, () => this._emitExtensionEvent(event));
-        this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
-        if (event.type === "agent_end") {
-            const entries = this.session.getEntries();
-            const ledger = readUsageLedger(entries);
-            const lastEntry = entries.at(-1);
-            if (ledger.checkpointId && !(lastEntry?.type === "custom" && lastEntry.customType === USAGE_LEDGER_ENTRY_TYPE))
-                this.session.appendCustomEntry(USAGE_LEDGER_ENTRY_TYPE, ledger);
-            this._scheduleExtensionCompactions();
-            if (!this._disposed && this.compressionDetectionEnabled)
-                this._compressionDetector.check(this.getContextUsage()?.percent, this.agent.state.messages, this._buildCurrentAgentContext().systemPrompt, getCompressibleEntries(this.session, ""));
-        }
-        if (event.type === "message_end") {
-            this._persistCompletedMessage(event.message);
-            this._applyPendingContextCompression(event.message);
-            this._updateRetryStateAfterAssistantMessage(event.message);
-        }
-    };
     _willRetryAfterAgentEnd(event) {
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled || this._retryAttempt >= settings.maxRetries) {
@@ -4104,6 +4097,7 @@ export class AgentSession {
             getSystemPrompt: () => this.systemPrompt,
             getToolOperations,
             getToolBackendInfo: () => this.getToolBackendInfo(),
+            isSandbox: () => this.isSandbox(),
             getLspStatus: getBoundLspStatus,
             configureLsp: (configuration) => {
                 if (runner !== this._extensionRunner)
@@ -4116,6 +4110,20 @@ export class AgentSession {
                 const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
                 return executeBashWithOperations(resolvedCommand, options?.cwd ?? operations.cwd, operations, options);
             }),
+            execHostCommand: (command, options) => {
+                const execute = () => this._runActivity("extension host command approval", () => this._executeApprovedHostCommand(runner, command, options));
+                const pending = this._hostCommandApprovalQueue.then(execute, execute);
+                this._hostCommandApprovalQueue = pending.then(() => undefined, () => undefined);
+                return pending;
+            },
+            execHostProcess: (executable, args, options) => {
+                const argv = Array.isArray(args) ? [...args] : args;
+                const request = { ...options };
+                const execute = () => this._runActivity("extension host process approval", () => this._executeApprovedHostProcess(runner, executable, argv, request));
+                const pending = this._hostCommandApprovalQueue.then(execute, execute);
+                this._hostCommandApprovalQueue = pending.then(() => undefined, () => undefined);
+                return pending;
+            },
         }, {
             registerProvider: (name, config) => {
                 this._modelRegistry.registerProvider(name, config);
@@ -4127,6 +4135,132 @@ export class AgentSession {
             },
         });
     }
+    async _executeApprovedHostCommand(runner, command, options) {
+        if (runner !== this._extensionRunner)
+            throw new Error(STALE_EXTENSION_CONTEXT_MESSAGE);
+        if (typeof command !== "string" ||
+            !command.trim() ||
+            typeof options?.question !== "string" ||
+            !options.question.trim()) {
+            throw new Error("Host command and approval question must be non-empty strings");
+        }
+        const operations = this._sandboxToolOperations;
+        if (!operations || operations !== this._toolOperations || operations.isDisconnected()) {
+            throw new Error("A connected sandbox is required for approved host commands");
+        }
+        if (!runner.hasUI())
+            throw new Error("Host command requires an interactive approval UI");
+        const signal = options.signal ?? this.agent.signal;
+        if (signal?.aborted)
+            throw new Error("Host command cancelled");
+        const hostCwd = await operations.mapWorkspaceDirectoryToHost(options.cwd ?? operations.cwd);
+        const choice = await runner
+            .getUIContext()
+            .select(`Run on host?\nReason: ${JSON.stringify(options.question)}\nCommand: ${JSON.stringify(command)}\nHost cwd: ${JSON.stringify(hostCwd)}`, ["No", "Yes"], { signal });
+        if (choice !== "Yes" || signal?.aborted)
+            throw new Error("Host command was not approved");
+        if (runner !== this._extensionRunner ||
+            operations !== this._sandboxToolOperations ||
+            operations.isDisconnected()) {
+            throw new Error("Sandbox changed before the host command could run");
+        }
+        return executeBashWithOperations(command, hostCwd, new LocalToolOperations(hostCwd), { ...options, signal });
+    }
+    async _executeApprovedHostProcess(runner, executable, args, options) {
+        if (runner !== this._extensionRunner)
+            throw new Error(STALE_EXTENSION_CONTEXT_MESSAGE);
+        if (typeof executable !== "string" ||
+            !executable.trim() ||
+            executable.includes("\0") ||
+            !Array.isArray(args) ||
+            args.some((arg) => typeof arg !== "string" || arg.includes("\0")) ||
+            !hasValidHostProcessApproval(options)) {
+            throw new Error("Host executable, argv and approval question must be valid strings");
+        }
+        const operations = this._sandboxToolOperations;
+        if (!operations || operations !== this._toolOperations || operations.isDisconnected()) {
+            throw new Error("A connected sandbox is required for approved host processes");
+        }
+        if (!runner.hasUI())
+            throw new Error("Host process requires an interactive approval UI");
+        const signal = options.signal ?? this.agent.signal;
+        if (signal?.aborted)
+            throw new Error("Host process cancelled");
+        const hostCwd = await operations.mapWorkspaceDirectoryToHost(options.cwd ?? operations.cwd);
+        const explanation = options.explanation === undefined ? "" : `\nExplanation (unverified): ${JSON.stringify(options.explanation)}`;
+        const choice = await runner
+            .getUIContext()
+            .select(`Run on host (no shell)?\nReason: ${JSON.stringify(options.question)}${explanation}\nExecutable: ${JSON.stringify(executable)}\nArguments: ${JSON.stringify(args)}\nHost cwd: ${JSON.stringify(hostCwd)}`, ["No", "Yes"], { signal });
+        if (choice !== "Yes" || signal?.aborted)
+            throw new Error("Host process was not approved");
+        if (runner !== this._extensionRunner ||
+            operations !== this._sandboxToolOperations ||
+            operations.isDisconnected()) {
+            throw new Error("Sandbox changed before the host process could run");
+        }
+        return execCommand(executable, args, hostCwd, { signal, timeout: options.timeout });
+    }
+    _createLoadSkillToolDefinition() {
+        const parameters = Type.Object({
+            name: Type.Union([Type.String(), Type.Array(Type.String())], {
+                description: "Name of a listed skill, or an array of skill names to load in one call",
+            }),
+        });
+        return {
+            name: "load_skill",
+            label: "Load skill",
+            description: "Load the full instructions for one or more available skills by name. Use the reported skill directory to resolve relative references. Hidden skills and unknown names are not available.",
+            promptSnippet: "Load instructions for available skills by name (or an array of names)",
+            parameters,
+            renderCall: (args, renderTheme, context) => {
+                const names = getToolNameArgs(args);
+                const expandKey = keyText("app.tools.expand");
+                const hint = !context.expanded && expandKey ? renderTheme.fg("dim", ` (${expandKey} to expand)`) : "";
+                return new Text(renderTheme.fg("customMessageLabel", `\x1b[1m[skill]\x1b[22m `) +
+                    renderTheme.fg("customMessageText", names.join(", ")) +
+                    hint, 0, 0);
+            },
+            renderResult: (result, options, renderTheme, context) => {
+                const output = options.expanded || context.isError ? getTextOutput(result, context.showImages) : "";
+                return new Text(output ? `\n${renderTheme.fg(context.isError ? "error" : "toolOutput", output)}` : "", 0, 0);
+            },
+            executionMode: "sequential",
+            execute: async (_toolCallId, params, signal) => {
+                if (signal?.aborted)
+                    throw new Error("Skill load cancelled");
+                const names = [...new Set(Array.isArray(params.name) ? params.name : [params.name])];
+                if (names.length === 0 || names.some((name) => !name))
+                    throw new Error("Specify at least one skill name");
+                const availableSkills = new Map(this.getRegisteredSkills()
+                    .filter((skill) => !skill.disableModelInvocation)
+                    .map((skill) => [skill.name, skill]));
+                const missing = names.filter((name) => !availableSkills.has(name));
+                if (missing.length > 0)
+                    throw new Error(`Skill not available: ${missing.join(", ")}`);
+                const skills = names.map((name) => availableSkills.get(name));
+                const content = await Promise.all(skills.map(async (skill) => {
+                    let text = skill.content;
+                    if (text === undefined && getSourceBackend(skill.sourceInfo) === "remote") {
+                        if (this.getToolBackendInfo().type !== "remote")
+                            throw new Error(`Remote skill not available: ${skill.name}`);
+                        text = (await this.getToolOperations().readFile(skill.filePath)).toString("utf-8");
+                    }
+                    else if (text === undefined) {
+                        text = await fsReadFile(resolvePath(skill.filePath, this._cwd), "utf-8");
+                    }
+                    return {
+                        type: "text",
+                        text: `Skill: ${JSON.stringify(skill.name)}\nSkill directory: ${JSON.stringify(skill.baseDir)}\nFile: ${JSON.stringify(skill.filePath)}\n\n${text}`,
+                    };
+                }));
+                if (signal?.aborted)
+                    throw new Error("Skill load cancelled");
+                for (const skill of skills)
+                    this._loadAssociatedInstructionTools(skill);
+                return { content, details: { names } };
+            },
+        };
+    }
     _createLoadToolDefinition() {
         const parameters = Type.Object({
             name: Type.Union([Type.String(), Type.Array(Type.String())], {
@@ -4477,6 +4611,7 @@ export class AgentSession {
             const baseToolDefinitions = this._createRuntimeBaseToolDefinitions(workspaceToolHost);
             this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions));
             this._initializeRuntimeLsp(operations);
+            this._baseToolDefinitions.set("load_skill", this._createLoadSkillToolDefinition());
             this._baseToolDefinitions.set("load_tool", this._createLoadToolDefinition());
             this._baseToolDefinitions.set("unload_tool", this._createUnloadToolDefinition());
             const extensionsResult = this._resourceLoader.getExtensions();