@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/grip-agent.js

@@ -0,0 +1,1243 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, posix, resolve, win32 } from "node:path";
+import { Agent } from "@greppleai/grip-agent-core";
+import { clampThinkingLevel, refreshModelCatalog, streamSimple, } from "@greppleai/grip-ai";
+import chalk from "chalk";
+import { getAgentDir } from "../config.js";
+import { InteractiveMode } from "../modes/interactive/interactive-mode.js";
+import { stopThemeWatcher } from "../modes/interactive/theme/theme.js";
+import { runPrintMode } from "../modes/print-mode.js";
+import { runRpcMode } from "../modes/rpc/rpc-mode.js";
+import { stripFrontmatter } from "../utils/frontmatter.js";
+import { AgentSession, getDefaultActiveToolNames } from "./agent-session.js";
+import { formatNoModelsAvailableMessage } from "./auth-guidance.js";
+import { AuthStorage } from "./auth-storage.js";
+import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { emitSessionShutdownEvent } from "./extensions/runner.js";
+import { freezeLoadedHooks, loadHooks } from "./hooks/config.js";
+import { canonicalProjectHookCwd, canonicalProjectHookIdentity } from "./hooks/trust-store.js";
+import { loadLspConfiguration, } from "./lsp/config-loader.js";
+import { convertToLlm } from "./messages.js";
+import { ModelRegistry } from "./model-registry.js";
+import { findInitialModel, resolveCliModel } from "./model-resolver.js";
+import { restoreStdout, takeOverStdout } from "./output-guard.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { InMemorySessionManager } from "./session/in-memory-session-manager.js";
+import { getDefaultSessionDir } from "./session/jsonl-helpers.js";
+import { LocalSessionManager } from "./session/local-session-manager.js";
+import { assertSessionCwdExists } from "./session-cwd.js";
+import { InMemorySettingsStorage, SettingsManager } from "./settings-manager.js";
+import { getSourceBackend } from "./source-info.js";
+import { isInstallTelemetryEnabled } from "./telemetry.js";
+import { printTimings, time } from "./timings.js";
+import { borrowToolOperations, } from "./tools/operations.js";
+export function isFatalGripAgentDiagnostic(diagnostic) {
+    return diagnostic.type === "error" && diagnostic.fatal !== false;
+}
+function formatLspConfigurationDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => ({
+        type: diagnostic.severity,
+        ...(diagnostic.severity === "error" ? { fatal: false } : {}),
+        message: `LSP configuration (${diagnostic.source}) ${diagnostic.path}: ${diagnostic.message}`,
+    }));
+}
+function formatHookDiagnostic(diagnostic) {
+    const source = diagnostic.source ? ` (${diagnostic.source.kind}: ${diagnostic.source.path})` : "";
+    return {
+        type: diagnostic.level,
+        fatal: false,
+        message: `Hook ${diagnostic.code}${source}: ${diagnostic.message}`,
+    };
+}
+export class SessionImportFileNotFoundError extends Error {
+    filePath;
+    constructor(filePath) {
+        super(`File not found: ${filePath}`);
+        this.name = "SessionImportFileNotFoundError";
+        this.filePath = filePath;
+    }
+}
+function isSubagentCwdConfined(cwd, operations, backend) {
+    if (backend?.type === "local")
+        return true;
+    if (backend === undefined)
+        return posix.normalize(cwd) === posix.normalize(operations.cwd);
+    const pathApi = backend?.type === "remote" && backend.configured && backend.workspace.pathFlavor === "windows" ? win32 : posix;
+    const relative = pathApi.relative(pathApi.normalize(operations.cwd), pathApi.normalize(cwd));
+    return (relative === "" ||
+        (relative !== ".." && !relative.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relative)));
+}
+function extractUserMessageText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+function blockImagesInMessage(message) {
+    if (message.role !== "user" && message.role !== "toolResult")
+        return message;
+    const { content } = message;
+    if (!Array.isArray(content) || !content.some((part) => part.type === "image"))
+        return message;
+    const filteredContent = content
+        .map((part) => (part.type === "image" ? { type: "text", text: "Image reading is disabled." } : part))
+        .filter((part, index, parts) => !(part.type === "text" &&
+        part.text === "Image reading is disabled." &&
+        index > 0 &&
+        parts[index - 1].type === "text" &&
+        parts[index - 1].text === "Image reading is disabled."));
+    return { ...message, content: filteredContent };
+}
+function asLspInputs(input) {
+    return input === undefined ? [] : Array.isArray(input) ? input : [input];
+}
+function getAttributionHeaders(model, settingsManager, sessionId) {
+    if (sessionId &&
+        (model.provider === "opencode" || model.provider === "opencode-go" || model.baseUrl.includes("opencode.ai"))) {
+        return { "x-opencode-session": sessionId, "x-opencode-client": "grip" };
+    }
+    if (!isInstallTelemetryEnabled(settingsManager)) {
+        return undefined;
+    }
+    if (model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai")) {
+        return {
+            "HTTP-Referer": "https://pi.dev",
+            "X-OpenRouter-Title": "grip",
+            "X-OpenRouter-Categories": "cli-agent",
+        };
+    }
+    if (model.provider === "cloudflare-workers-ai" ||
+        model.provider === "cloudflare-ai-gateway" ||
+        model.baseUrl.includes("api.cloudflare.com") ||
+        model.baseUrl.includes("gateway.ai.cloudflare.com")) {
+        return {
+            "User-Agent": "grip-coding-agent",
+        };
+    }
+    return undefined;
+}
+function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
+    if (!extensionFlagValues) {
+        return [];
+    }
+    const diagnostics = [];
+    const extensionsResult = resourceLoader.getExtensions();
+    const registeredFlags = new Map();
+    for (const extension of extensionsResult.extensions) {
+        for (const [name, flag] of extension.flags) {
+            registeredFlags.set(name, { type: flag.type });
+        }
+    }
+    const unknownFlags = [];
+    for (const [name, value] of extensionFlagValues) {
+        const flag = registeredFlags.get(name);
+        if (!flag) {
+            unknownFlags.push(name);
+            continue;
+        }
+        if (flag.type === "boolean") {
+            extensionsResult.runtime.flagValues.set(name, true);
+            continue;
+        }
+        if (typeof value === "string") {
+            extensionsResult.runtime.flagValues.set(name, value);
+            continue;
+        }
+        diagnostics.push({
+            type: "error",
+            message: `Extension flag "--${name}" requires a value`,
+        });
+    }
+    if (unknownFlags.length > 0) {
+        diagnostics.push({
+            type: "error",
+            message: `Unknown option${unknownFlags.length === 1 ? "" : "s"}: ${unknownFlags.map((name) => `--${name}`).join(", ")}`,
+        });
+    }
+    return diagnostics;
+}
+async function runInteractiveAppMode(runtimeHost, modelFallbackMessage, options) {
+    const interactiveMode = new InteractiveMode(runtimeHost, {
+        migratedProviders: options.migratedProviders,
+        modelFallbackMessage,
+        initialMessage: options.initialMessage,
+        initialImages: options.initialImages,
+        initialMessages: options.initialMessages,
+        verbose: options.verbose,
+        tuiMode: options.tuiMode,
+    });
+    if (options.startupBenchmark) {
+        await interactiveMode.init();
+        time("interactiveMode.init");
+        // Give the TUI's stdin handler a brief chance to consume terminal query replies
+        // (Kitty keyboard protocol, device attributes, cell size) before restoring the terminal.
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        interactiveMode.stop();
+        stopThemeWatcher();
+        printTimings();
+        if (process.stdout.writableLength > 0) {
+            await new Promise((resolve) => process.stdout.once("drain", resolve));
+        }
+        if (process.stderr.writableLength > 0) {
+            await new Promise((resolve) => process.stderr.once("drain", resolve));
+        }
+        return;
+    }
+    printTimings();
+    await interactiveMode.run();
+}
+/**
+ * Application-level composition root for grip's coding agent runtime.
+ *
+ * GripAgent owns common app services, the session lifecycle backend, and the
+ * current active AgentSession. Conversation behavior stays in AgentSession;
+ * session lifecycle/discovery stays in SessionManager implementations.
+ */
+export class GripAgent {
+    initialCwd;
+    agentDir;
+    sessionManager;
+    authStorage;
+    options;
+    _mode;
+    _session;
+    _services;
+    _diagnostics = [];
+    _baseDiagnostics = [];
+    _hookConfigurationDiagnostics = [];
+    _hookRuntimeDiagnostics = [];
+    _lspDiagnostics = [];
+    _modelFallbackMessage;
+    rebindSession;
+    beforeSessionInvalidate;
+    borrowedToolOperations;
+    toolOperationsDisposed = false;
+    disposePromise;
+    subagentCleanupCallbacks = new Set();
+    constructor(options, resolved) {
+        this.options = options;
+        this.borrowedToolOperations = options.toolOperations ? borrowToolOperations(options.toolOperations) : undefined;
+        this._mode = options.mode ?? "embedded";
+        this.initialCwd = resolved.cwd;
+        this.agentDir = resolved.agentDir;
+        this.sessionManager = resolved.sessionManager;
+        this.authStorage = resolved.authStorage;
+    }
+    static setupStdio(options) {
+        if (options.mode !== "embedded" && options.mode !== "interactive") {
+            takeOverStdout();
+        }
+    }
+    static async create(options = {}) {
+        const cwd = options.cwd ?? process.cwd();
+        const agentDir = options.agentDir ?? getAgentDir();
+        const sessionManager = options.sessionManager ?? new LocalSessionManager({ cwd, sessionDir: getDefaultSessionDir(cwd, agentDir) });
+        const authStorage = options.authStorage ?? AuthStorage.create(join(agentDir, "auth.json"));
+        return new GripAgent(options, { cwd, agentDir, sessionManager, authStorage });
+    }
+    get mode() {
+        return this._mode;
+    }
+    get cwd() {
+        return this._services?.cwd ?? this.initialCwd;
+    }
+    async readPipedStdin() {
+        if (this._mode === "embedded" || this._mode === "rpc" || process.stdin.isTTY) {
+            return undefined;
+        }
+        const stdinContent = await new Promise((resolve) => {
+            let data = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on("end", () => {
+                resolve(data.trim() || undefined);
+            });
+            process.stdin.resume();
+        });
+        if (stdinContent !== undefined && this._mode === "interactive") {
+            this._mode = "print";
+        }
+        return stdinContent;
+    }
+    async createServices(cwd) {
+        const settingsManager = this.options.settingsManager ?? SettingsManager.create(cwd, this.agentDir);
+        if (process.env.GRIP_MODEL_CATALOG_URL) {
+            await refreshModelCatalog().catch(() => undefined);
+        }
+        const modelRegistry = this.options.modelRegistry ?? ModelRegistry.create(this.authStorage, join(this.agentDir, "models.json"));
+        const resourceLoader = this.options.resourceLoader ??
+            new DefaultResourceLoader({
+                ...(this.options.resourceLoaderOptions ?? {}),
+                cwd,
+                agentDir: this.agentDir,
+                settingsManager,
+                toolOperations: this.options.resourceLoaderOptions?.toolOperations
+                    ? borrowToolOperations(this.options.resourceLoaderOptions.toolOperations)
+                    : this.borrowedToolOperations,
+            });
+        await resourceLoader.reload();
+        const diagnostics = [];
+        const extensionsResult = resourceLoader.getExtensions();
+        for (const { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
+            try {
+                modelRegistry.registerProvider(name, config);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                diagnostics.push({
+                    type: "error",
+                    message: `Extension "${extensionPath}" error: ${message}`,
+                });
+            }
+        }
+        extensionsResult.runtime.pendingProviderRegistrations = [];
+        diagnostics.push(...applyExtensionFlagValues(resourceLoader, this.options.extensionFlagValues));
+        return {
+            cwd,
+            agentDir: this.agentDir,
+            authStorage: this.authStorage,
+            settingsManager,
+            modelRegistry,
+            resourceLoader,
+            diagnostics,
+        };
+    }
+    createSubagentRunRegistry() {
+        const runs = new Map();
+        return {
+            list: () => Array.from(runs.values()).sort((a, b) => a.createdAt.localeCompare(b.createdAt)),
+            upsert: (run) => runs.set(run.runId, structuredClone(run)),
+            get: (runId) => runs.get(runId),
+        };
+    }
+    createSubagentConfigRegistry() {
+        const configs = new Map();
+        return {
+            list: () => Array.from(configs.values()).sort((a, b) => a.createdAt.localeCompare(b.createdAt)),
+            upsert: (config) => configs.set(config.name, structuredClone(config)),
+            get: (name) => configs.get(name),
+        };
+    }
+    resolveEmbeddedSubagentRequest(request, services) {
+        const resolvedModel = request.model
+            ? resolveCliModel({ cliModel: request.model, modelRegistry: services.modelRegistry })
+            : undefined;
+        if (resolvedModel?.error)
+            return { failure: { exitCode: 1, stderr: resolvedModel.error } };
+        const toolOperations = request.toolOperations;
+        if (!toolOperations) {
+            return { failure: { exitCode: 1, stderr: "Subagents require explicit workspace tool operations" } };
+        }
+        const backendInfo = toolOperations.getBackendInfo?.();
+        if (backendInfo?.type === "remote" && !backendInfo.configured) {
+            return { failure: { exitCode: 1, stderr: "Subagents cannot run with an unconfigured remote backend" } };
+        }
+        if (!isSubagentCwdConfined(request.cwd, toolOperations, backendInfo)) {
+            return {
+                failure: {
+                    exitCode: 1,
+                    stderr: `Sandboxed subagent cwd must stay within the sandbox workspace root: ${toolOperations.cwd}`,
+                },
+            };
+        }
+        const backendIdentity = JSON.stringify(backendInfo ?? { type: "unknown", cwd: toolOperations.cwd });
+        return { context: { resolvedModel, toolOperations, backendInfo, backendIdentity } };
+    }
+    selectEmbeddedSubagentSkills(request, services) {
+        const requestedSkills = request.skills ?? [];
+        const loadedSkills = services.resourceLoader.getSkills().skills;
+        const skillsByName = new Map();
+        for (const skill of loadedSkills) {
+            if (!skillsByName.has(skill.name))
+                skillsByName.set(skill.name, skill);
+        }
+        const missingSkills = [];
+        const skills = [];
+        for (const name of requestedSkills) {
+            const skill = skillsByName.get(name);
+            if (skill)
+                skills.push(skill);
+            else
+                missingSkills.push(name);
+        }
+        if (missingSkills.length > 0) {
+            return { failure: { exitCode: 1, stderr: `Unknown subagent skill(s): ${missingSkills.join(", ")}` } };
+        }
+        return { skills };
+    }
+    async loadEmbeddedSubagentSkillContent(skill, toolOperations, backendInfo) {
+        if (skill.content !== undefined)
+            return skill.content;
+        if (backendInfo?.type === "local")
+            return readFileSync(skill.filePath, "utf-8");
+        if (getSourceBackend(skill.sourceInfo) === "local") {
+            throw new Error("local skill files are unavailable to a sandboxed subagent");
+        }
+        return (await toolOperations.readFile(skill.filePath)).toString("utf-8");
+    }
+    async preloadEmbeddedSubagentSkills(skills, context) {
+        const blocks = [];
+        for (const skill of skills) {
+            try {
+                const content = await this.loadEmbeddedSubagentSkillContent(skill, context.toolOperations, context.backendInfo);
+                blocks.push(`<preloaded-skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${stripFrontmatter(content).trim()}\n</preloaded-skill>`);
+            }
+            catch (error) {
+                return {
+                    failure: {
+                        exitCode: 1,
+                        stderr: `Failed to preload subagent skill ${skill.name}: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                };
+            }
+        }
+        return { blocks };
+    }
+    async createEmbeddedSubagentChild(request, requestContext, runnerContext, runId) {
+        const settingsStorage = new InMemorySettingsStorage();
+        settingsStorage.withLock("global", () => JSON.stringify(runnerContext.services.settingsManager.getGlobalSettings()));
+        settingsStorage.withLock("project", () => JSON.stringify(runnerContext.services.settingsManager.getProjectSettings()));
+        const settingsManager = SettingsManager.fromStorage(settingsStorage);
+        const selection = this.selectEmbeddedSubagentSkills(request, runnerContext.services);
+        if (selection.failure)
+            return selection;
+        const preload = await this.preloadEmbeddedSubagentSkills(selection.skills, requestContext);
+        if (preload.failure)
+            return preload;
+        const childExcludedTools = new Set([
+            "subagent",
+            "subagent_runs",
+            "create_subagent",
+            ...runnerContext.excludedTools,
+        ]);
+        const requestedTools = request.tools ?? getDefaultActiveToolNames();
+        const skillTools = selection.skills.flatMap((skill) => skill.tools ?? []);
+        const tools = Array.from(new Set([...requestedTools, ...skillTools])).filter((name) => !childExcludedTools.has(name));
+        const child = await GripAgent.create({
+            mode: "embedded",
+            cwd: request.cwd,
+            agentDir: runnerContext.services.agentDir,
+            sessionManager: new InMemorySessionManager(request.cwd),
+            authStorage: runnerContext.services.authStorage,
+            modelRegistry: runnerContext.services.modelRegistry,
+            settingsManager,
+            model: requestContext.resolvedModel?.model,
+            thinkingLevel: requestContext.resolvedModel?.thinkingLevel,
+            tools,
+            excludedTools: Array.from(childExcludedTools),
+            toolOperations: requestContext.toolOperations,
+            resourceLoaderOptions: {
+                toolOperations: requestContext.toolOperations,
+                noExtensions: true,
+                noSkills: true,
+                noRules: true,
+                noPromptTemplates: true,
+                noThemes: true,
+                noContextFiles: true,
+                systemPrompt: "",
+                appendSystemPrompt: [],
+                systemPromptOverride: () => undefined,
+                appendSystemPromptOverride: () => [request.systemPrompt, ...preload.blocks],
+            },
+        });
+        const session = await child.createAgentSession();
+        const now = new Date().toISOString();
+        const run = {
+            runId,
+            sessionReference: session.sessionReference,
+            status: "running",
+            agent: request.agent,
+            task: request.task,
+            cwd: request.cwd,
+            model: request.model,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const childState = {
+            child,
+            session,
+            run,
+            toolOperations: requestContext.toolOperations,
+            backendIdentity: requestContext.backendIdentity,
+        };
+        runnerContext.runtime.children.set(runId, childState);
+        runnerContext.registry.upsert(run);
+        return { childState };
+    }
+    async prepareEmbeddedSubagentChild(request, requestContext, runnerContext) {
+        const continuedRunId = request.continueSession;
+        const childState = continuedRunId ? runnerContext.runtime.children.get(continuedRunId) : undefined;
+        if (request.continueSession && !childState) {
+            return { failure: { exitCode: 1, stderr: `Unknown subagent run id: ${request.continueSession}` } };
+        }
+        if (childState &&
+            (childState.toolOperations !== requestContext.toolOperations ||
+                childState.backendIdentity !== requestContext.backendIdentity)) {
+            await childState.child.dispose();
+            runnerContext.runtime.children.delete(childState.run.runId);
+            childState.run = { ...childState.run, status: "failed", updatedAt: new Date().toISOString() };
+            runnerContext.registry.upsert(childState.run);
+            return {
+                failure: {
+                    exitCode: 1,
+                    stderr: "The parent workspace backend changed; start a new subagent instead of continuing this run",
+                },
+            };
+        }
+        if (!childState) {
+            const runId = `subagent:${runnerContext.runtime.nextRunNumber++}`;
+            const creation = await this.createEmbeddedSubagentChild(request, requestContext, runnerContext, runId);
+            if (creation.failure)
+                return creation;
+            return { childState: creation.childState, runId };
+        }
+        childState.run = {
+            ...childState.run,
+            status: "running",
+            task: request.task,
+            updatedAt: new Date().toISOString(),
+        };
+        runnerContext.registry.upsert(childState.run);
+        return { childState, runId: childState.run.runId };
+    }
+    subscribeToEmbeddedSubagentRun(childState, request, output, registry) {
+        return childState.session.subscribe((event) => {
+            if (event.type !== "message_end")
+                return;
+            if (event.message.role === "assistant" || event.message.role === "toolResult") {
+                request.onMessage(event.message);
+            }
+            if (event.message.role !== "assistant")
+                return;
+            output.lastOutput =
+                event.message.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n") || output.lastOutput;
+            childState.run = {
+                ...childState.run,
+                lastOutput: output.lastOutput,
+                updatedAt: new Date().toISOString(),
+            };
+            registry.upsert(childState.run);
+        });
+    }
+    async executeEmbeddedSubagentRun(request, preparation, registry) {
+        const { childState, runId } = preparation;
+        const session = childState.session;
+        const output = { lastOutput: childState.run.lastOutput };
+        let unsubscribe;
+        const abort = () => {
+            void session.abort();
+        };
+        try {
+            unsubscribe = this.subscribeToEmbeddedSubagentRun(childState, request, output, registry);
+            if (request.signal?.aborted) {
+                return {
+                    exitCode: 1,
+                    stderr: "Subagent was aborted",
+                    runId,
+                    sessionReference: session.sessionReference,
+                };
+            }
+            request.signal?.addEventListener("abort", abort, { once: true });
+            await session.prompt(request.prompt);
+            const status = request.signal?.aborted ? "failed" : "completed";
+            childState.run = {
+                ...childState.run,
+                status,
+                lastOutput: output.lastOutput,
+                updatedAt: new Date().toISOString(),
+            };
+            registry.upsert(childState.run);
+            return {
+                exitCode: request.signal?.aborted ? 1 : 0,
+                stderr: "",
+                runId,
+                sessionReference: session.sessionReference,
+            };
+        }
+        catch (error) {
+            childState.run = {
+                ...childState.run,
+                status: "failed",
+                updatedAt: new Date().toISOString(),
+            };
+            registry.upsert(childState.run);
+            return {
+                exitCode: 1,
+                stderr: error instanceof Error ? error.message : String(error),
+                runId,
+                sessionReference: session.sessionReference,
+            };
+        }
+        finally {
+            request.signal?.removeEventListener("abort", abort);
+            unsubscribe?.();
+        }
+    }
+    async runEmbeddedSubagent(request, runnerContext) {
+        const resolution = this.resolveEmbeddedSubagentRequest(request, runnerContext.services);
+        if (resolution.failure)
+            return resolution.failure;
+        const preparation = await this.prepareEmbeddedSubagentChild(request, resolution.context, runnerContext);
+        if (preparation.failure)
+            return preparation.failure;
+        return this.executeEmbeddedSubagentRun(request, preparation, runnerContext.registry);
+    }
+    createEmbeddedSubagentRunner(services, excludedTools, registry) {
+        const runtime = { nextRunNumber: 1, children: new Map() };
+        const runnerContext = { services, excludedTools, registry, runtime };
+        const cleanup = async () => {
+            for (const { child } of runtime.children.values())
+                await child.dispose();
+            runtime.children.clear();
+        };
+        this.subagentCleanupCallbacks.add(cleanup);
+        return (request) => this.runEmbeddedSubagent(request, runnerContext);
+    }
+    shouldDiscoverProjectHooks(resolvedOptions) {
+        const hookOperations = resolvedOptions.toolOperations ?? this.borrowedToolOperations;
+        const customHookOperationsSupplied = resolvedOptions.toolOperations !== undefined || this.borrowedToolOperations !== undefined;
+        const hookBackend = hookOperations?.getBackendInfo?.();
+        const trustProjectHooks = resolvedOptions.trustProjectHooks ?? this.options.trustProjectHooks;
+        return trustProjectHooks === true && (!customHookOperationsSupplied || hookBackend?.type === "local");
+    }
+    resolveHookDiscovery(services, resolvedOptions, diagnostics, discoverProjectHooks) {
+        const trustedIdentity = resolvedOptions.trustedProjectHooksIdentity ?? this.options.trustedProjectHooksIdentity;
+        let cwd = services.cwd;
+        if (!discoverProjectHooks)
+            return { cwd, discoverProjectHooks };
+        try {
+            cwd = canonicalProjectHookCwd(services.cwd);
+            if (trustedIdentity && canonicalProjectHookIdentity(cwd) !== trustedIdentity) {
+                discoverProjectHooks = false;
+                diagnostics.push({
+                    type: "warning",
+                    message: "Project hook trust identity changed before hook loading; project hooks were not loaded",
+                });
+            }
+        }
+        catch (error) {
+            discoverProjectHooks = false;
+            diagnostics.push({
+                type: "warning",
+                message: `Unable to canonicalize project hooks path; project hooks were not loaded: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        return { cwd, discoverProjectHooks };
+    }
+    async loadSessionHooks(services, resolvedOptions, discoverProjectHooks) {
+        const diagnostics = [];
+        const hookOptions = this.options.hooks;
+        const discovery = this.resolveHookDiscovery(services, resolvedOptions, diagnostics, discoverProjectHooks);
+        if (hookOptions === false || hookOptions?.enabled === false) {
+            return { loadedHooks: undefined, diagnostics };
+        }
+        const loadedHooks = hookOptions?.snapshot
+            ? freezeLoadedHooks(hookOptions.snapshot)
+            : await loadHooks({
+                cwd: discovery.cwd,
+                home: hookOptions?.home,
+                agentDir: services.agentDir,
+                sources: discovery.discoverProjectHooks ? ["user", "project", "local"] : ["user"],
+            });
+        diagnostics.push(...loadedHooks.diagnostics.map(formatHookDiagnostic));
+        return { loadedHooks, diagnostics };
+    }
+    mergeSessionOptions(resolvedOptions) {
+        return {
+            model: resolvedOptions.model ?? this.options.model,
+            thinkingLevel: resolvedOptions.thinkingLevel ?? this.options.thinkingLevel,
+            scopedModels: resolvedOptions.scopedModels ?? this.options.scopedModels,
+            tools: resolvedOptions.tools ?? this.options.tools,
+            enableLspTools: resolvedOptions.enableLspTools ?? this.options.enableLspTools,
+            excludedTools: resolvedOptions.excludedTools ?? this.options.excludedTools,
+            noTools: resolvedOptions.noTools ?? this.options.noTools,
+            customTools: resolvedOptions.customTools ?? this.options.customTools,
+            toolOperations: resolvedOptions.toolOperations
+                ? borrowToolOperations(resolvedOptions.toolOperations)
+                : this.borrowedToolOperations,
+            trustProjectAgents: resolvedOptions.trustProjectAgents ?? this.options.trustProjectAgents,
+            trustProjectHooks: resolvedOptions.trustProjectHooks ?? this.options.trustProjectHooks,
+            trustProjectLspTransports: resolvedOptions.trustProjectLspTransports ?? this.options.trustProjectLspTransports,
+            lspConnectionFactories: resolvedOptions.lspConnectionFactories ?? this.options.lspConnectionFactories,
+        };
+    }
+    resolveSessionLspConfiguration(services, sessionOptions, inputs) {
+        if (sessionOptions.toolOperations?.getBackendInfo?.().type === "remote") {
+            return Promise.resolve({ configuration: { enabled: false, servers: [] }, diagnostics: [] });
+        }
+        return loadLspConfiguration({
+            settingsManager: services.settingsManager,
+            cwd: services.cwd,
+            agentDir: services.agentDir,
+            inputs,
+            trustProjectLspTransports: sessionOptions.trustProjectLspTransports,
+        });
+    }
+    async resolveSessionModel(services, sessionOptions, existingSession) {
+        let model = sessionOptions.model;
+        let fallbackMessage;
+        if (model)
+            model = services.modelRegistry.find(model.provider, model.id) ?? model;
+        if (!model && existingSession.messages.length > 0 && existingSession.model) {
+            const restoredModel = services.modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
+            if (restoredModel && services.modelRegistry.hasConfiguredAuth(restoredModel))
+                model = restoredModel;
+            if (!model)
+                fallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+        }
+        if (model)
+            return { model, fallbackMessage };
+        const result = await findInitialModel({
+            scopedModels: [],
+            isContinuing: existingSession.messages.length > 0,
+            defaultProvider: services.settingsManager.getDefaultProvider(),
+            defaultModelId: services.settingsManager.getDefaultModel(),
+            defaultThinkingLevel: services.settingsManager.getDefaultThinkingLevel(),
+            modelRegistry: services.modelRegistry,
+        });
+        model = result.model;
+        if (!model)
+            fallbackMessage = formatNoModelsAvailableMessage();
+        else if (fallbackMessage)
+            fallbackMessage += `. Using ${model.provider}/${model.id}`;
+        return { model, fallbackMessage };
+    }
+    resolveSessionThinkingLevel(services, activeSession, existingSession, configuredLevel, model) {
+        const hasExistingSession = existingSession.messages.length > 0;
+        const hasThinkingEntry = activeSession.getBranch().some((entry) => entry.type === "thinking_level_change");
+        let thinkingLevel = configuredLevel;
+        if (thinkingLevel === undefined && hasExistingSession) {
+            thinkingLevel = hasThinkingEntry
+                ? existingSession.thinkingLevel
+                : (services.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
+        }
+        thinkingLevel ??= services.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        return model ? clampThinkingLevel(model, thinkingLevel) : "off";
+    }
+    createCoreAgent(services, activeSession, model, thinkingLevel, extensionRunnerRef) {
+        return new Agent({
+            initialState: { systemPrompt: "", model, thinkingLevel, tools: [] },
+            convertToLlm: (messages) => {
+                const converted = convertToLlm(messages);
+                return services.settingsManager.getBlockImages() ? converted.map(blockImagesInMessage) : converted;
+            },
+            streamFn: async (streamModel, context, options) => {
+                const auth = await services.modelRegistry.getApiKeyAndHeaders(streamModel);
+                if (!auth.ok)
+                    throw new Error(auth.error);
+                const providerRetrySettings = services.settingsManager.getProviderRetrySettings();
+                const timeoutMs = options?.timeoutMs ??
+                    providerRetrySettings.timeoutMs ??
+                    (streamModel.api === "openai-codex-responses"
+                        ? services.settingsManager.getHttpIdleTimeoutMs()
+                        : undefined);
+                const websocketConnectTimeoutMs = options?.websocketConnectTimeoutMs ?? services.settingsManager.getWebSocketConnectTimeoutMs();
+                const attributionHeaders = getAttributionHeaders(streamModel, services.settingsManager, options?.sessionId);
+                let headers = attributionHeaders || auth.headers || options?.headers
+                    ? { ...attributionHeaders, ...auth.headers, ...options?.headers }
+                    : undefined;
+                const runner = extensionRunnerRef.current;
+                if (runner?.hasHandlers("before_provider_headers")) {
+                    headers = await runner.emitBeforeProviderHeaders(headers ?? {});
+                }
+                return streamSimple(streamModel, context, {
+                    ...options,
+                    apiKey: auth.apiKey,
+                    timeoutMs,
+                    websocketConnectTimeoutMs,
+                    maxRetries: options?.maxRetries ?? providerRetrySettings.maxRetries,
+                    maxRetryDelayMs: options?.maxRetryDelayMs ?? providerRetrySettings.maxRetryDelayMs,
+                    headers,
+                });
+            },
+            onPayload: async (payload) => {
+                const runner = extensionRunnerRef.current;
+                return runner?.hasHandlers("before_provider_request") ? runner.emitBeforeProviderRequest(payload) : payload;
+            },
+            onResponse: async (response) => {
+                const runner = extensionRunnerRef.current;
+                if (!runner?.hasHandlers("after_provider_response"))
+                    return;
+                await runner.emit({ type: "after_provider_response", status: response.status, headers: response.headers });
+            },
+            sessionId: activeSession.getSessionId(),
+            transformContext: async (messages) => {
+                const runner = extensionRunnerRef.current;
+                return runner ? runner.emitContext(messages) : messages;
+            },
+            steeringMode: services.settingsManager.getSteeringMode(),
+            followUpMode: services.settingsManager.getFollowUpMode(),
+            transport: services.settingsManager.getTransport(),
+            thinkingBudgets: services.settingsManager.getThinkingBudgets(),
+            maxRetryDelayMs: services.settingsManager.getProviderRetrySettings().maxRetryDelayMs,
+        });
+    }
+    async buildAgentSession(activeSession, sessionStartEvent) {
+        const services = await this.createServices(activeSession.getCwd());
+        const diagnostics = [
+            ...services.diagnostics,
+            ...services.resourceLoader.getExtensions().errors.map(({ path, error }) => ({
+                type: "error",
+                message: `Failed to load extension "${path}": ${error}`,
+            })),
+        ];
+        const resolvedOptions = (await this.options.resolveSessionOptions?.({ services, session: activeSession, sessionStartEvent })) ?? {};
+        diagnostics.push(...(resolvedOptions.diagnostics ?? []));
+        const discoverProjectHooks = this.shouldDiscoverProjectHooks(resolvedOptions);
+        const hookResolution = await this.loadSessionHooks(services, resolvedOptions, discoverProjectHooks);
+        const sessionOptions = this.mergeSessionOptions(resolvedOptions);
+        const lspInputs = [...asLspInputs(this.options.lsp), ...asLspInputs(resolvedOptions.lsp)];
+        const resolveSessionLspConfiguration = () => this.resolveSessionLspConfiguration(services, sessionOptions, lspInputs);
+        const lspResult = await resolveSessionLspConfiguration();
+        const lspDiagnostics = formatLspConfigurationDiagnostics(lspResult.diagnostics);
+        const baseDiagnostics = [...diagnostics];
+        const existingSession = activeSession.buildSessionContext();
+        const hasExistingSession = existingSession.messages.length > 0;
+        const hasThinkingEntry = activeSession.getBranch().some((entry) => entry.type === "thinking_level_change");
+        const modelResolution = await this.resolveSessionModel(services, sessionOptions, existingSession);
+        const { model } = modelResolution;
+        const thinkingLevel = this.resolveSessionThinkingLevel(services, activeSession, existingSession, sessionOptions.thinkingLevel, model);
+        const defaultActiveToolNames = getDefaultActiveToolNames(services.settingsManager.getEnableSubagents(), sessionOptions.enableLspTools ?? services.settingsManager.getEnableLspTools());
+        const allowedToolNames = sessionOptions.tools ?? (sessionOptions.noTools === "all" ? [] : undefined);
+        const initialActiveToolNames = [
+            ...(sessionOptions.tools ?? (sessionOptions.noTools ? [] : defaultActiveToolNames)),
+        ];
+        const extensionRunnerRef = {};
+        const agent = this.createCoreAgent(services, activeSession, model, thinkingLevel, extensionRunnerRef);
+        if (hasExistingSession) {
+            agent.state.messages = existingSession.messages;
+            if (!hasThinkingEntry)
+                activeSession.appendThinkingLevelChange(thinkingLevel);
+        }
+        else {
+            if (model)
+                activeSession.appendModelChange(model.provider, model.id);
+            activeSession.appendThinkingLevelChange(thinkingLevel);
+        }
+        const subagentRunRegistry = this.createSubagentRunRegistry();
+        const subagentConfigRegistry = this.createSubagentConfigRegistry();
+        const hookOptions = this.options.hooks;
+        return {
+            session: new AgentSession({
+                agent,
+                session: activeSession,
+                settingsManager: services.settingsManager,
+                cwd: services.cwd,
+                scopedModels: sessionOptions.scopedModels,
+                resourceLoader: services.resourceLoader,
+                customTools: sessionOptions.customTools,
+                toolOperations: sessionOptions.toolOperations,
+                modelRegistry: services.modelRegistry,
+                initialActiveToolNames,
+                enableLspTools: sessionOptions.enableLspTools,
+                excludedToolNames: sessionOptions.excludedTools,
+                allowedToolNames,
+                subagentRunner: this.createEmbeddedSubagentRunner(services, sessionOptions.excludedTools ?? [], subagentRunRegistry),
+                subagentRunRegistry,
+                subagentConfigRegistry,
+                trustProjectAgents: sessionOptions.trustProjectAgents,
+                lspConfiguration: lspResult.configuration,
+                lspConnectionFactories: sessionOptions.lspConnectionFactories,
+                resolveLspConfiguration: resolveSessionLspConfiguration,
+                onLspConfigurationDiagnostics: (nextDiagnostics) => {
+                    this.setLspConfigurationDiagnostics(nextDiagnostics);
+                },
+                extensionRunnerRef,
+                sessionStartEvent,
+                loadedHooks: hookResolution.loadedHooks,
+                resolveHooks: async () => {
+                    const nextResolution = await this.loadSessionHooks(services, resolvedOptions, discoverProjectHooks);
+                    this.setHookConfigurationDiagnostics(nextResolution.diagnostics);
+                    return nextResolution.loadedHooks;
+                },
+                hookRunOptions: hookOptions
+                    ? {
+                        allowedHttpHookUrls: hookOptions.allowedHttpHookUrls,
+                        httpHookAllowedEnvVars: hookOptions.httpHookAllowedEnvVars,
+                    }
+                    : undefined,
+                onHookDiagnostic: (diagnostic) => this.addHookDiagnostic(diagnostic),
+            }),
+            services,
+            baseDiagnostics,
+            hookDiagnostics: hookResolution.diagnostics,
+            lspDiagnostics,
+            modelFallbackMessage: modelResolution.fallbackMessage,
+        };
+    }
+    apply(result) {
+        this._session = result.session;
+        this._services = result.services;
+        this._baseDiagnostics = result.baseDiagnostics;
+        this._hookConfigurationDiagnostics = result.hookDiagnostics;
+        this._hookRuntimeDiagnostics = [];
+        this._lspDiagnostics = result.lspDiagnostics;
+        this.refreshDiagnostics();
+        this._modelFallbackMessage = result.modelFallbackMessage;
+    }
+    refreshDiagnostics() {
+        this._diagnostics = [
+            ...this._baseDiagnostics,
+            ...this._hookConfigurationDiagnostics,
+            ...this._hookRuntimeDiagnostics,
+            ...this._lspDiagnostics,
+        ];
+    }
+    setLspConfigurationDiagnostics(diagnostics) {
+        this._lspDiagnostics = formatLspConfigurationDiagnostics(diagnostics);
+        this.refreshDiagnostics();
+    }
+    setHookConfigurationDiagnostics(diagnostics) {
+        this._hookConfigurationDiagnostics = [...diagnostics];
+        this.refreshDiagnostics();
+    }
+    addHookDiagnostic(diagnostic) {
+        this._hookRuntimeDiagnostics.push(formatHookDiagnostic(diagnostic));
+        this.refreshDiagnostics();
+    }
+    shouldValidateSessionCwdOnHost() {
+        const backendInfo = this.borrowedToolOperations?.getBackendInfo?.();
+        return backendInfo === undefined || backendInfo.type === "local";
+    }
+    async createAgentSession(options = {}) {
+        const initialSession = options.session ?? (await this.sessionManager.create());
+        if (this.shouldValidateSessionCwdOnHost()) {
+            assertSessionCwdExists(initialSession, initialSession.getCwd());
+        }
+        this.apply(await this.buildAgentSession(initialSession, options.sessionStartEvent));
+        return this.session;
+    }
+    get runtime() {
+        if (!this._session) {
+            throw new Error("GripAgent session has not been created. Call createAgentSession() first.");
+        }
+        return this;
+    }
+    get services() {
+        if (!this._services) {
+            throw new Error("GripAgent services have not been created. Call createAgentSession() first.");
+        }
+        return this._services;
+    }
+    get session() {
+        if (!this._session) {
+            throw new Error("GripAgent session has not been created. Call createAgentSession() first.");
+        }
+        return this._session;
+    }
+    get modelFallbackMessage() {
+        return this._modelFallbackMessage;
+    }
+    get settingsManager() {
+        return this.services.settingsManager;
+    }
+    get modelRegistry() {
+        return this.services.modelRegistry;
+    }
+    get resourceLoader() {
+        return this.services.resourceLoader;
+    }
+    get diagnostics() {
+        return this._diagnostics;
+    }
+    get currentCwd() {
+        return this.services.cwd;
+    }
+    setRebindSession(rebindSession) {
+        this.rebindSession = rebindSession;
+    }
+    setBeforeSessionInvalidate(beforeSessionInvalidate) {
+        this.beforeSessionInvalidate = beforeSessionInvalidate;
+    }
+    async emitBeforeSwitch(reason, targetSessionReference) {
+        const runner = this.session.extensionRunner;
+        if (!runner.hasHandlers("session_before_switch")) {
+            return { cancelled: false };
+        }
+        const result = await runner.emit({
+            type: "session_before_switch",
+            reason,
+            targetSessionReference,
+            targetSessionFile: targetSessionReference,
+        });
+        return { cancelled: result?.cancel === true };
+    }
+    async emitBeforeFork(entryId, options) {
+        const runner = this.session.extensionRunner;
+        if (!runner.hasHandlers("session_before_fork")) {
+            return { cancelled: false };
+        }
+        const result = await runner.emit({
+            type: "session_before_fork",
+            entryId,
+            ...options,
+        });
+        return { cancelled: result?.cancel === true };
+    }
+    async flushSession(session) {
+        const flushPendingSync = session.session.flushPendingSync;
+        if (flushPendingSync) {
+            await flushPendingSync.call(session.session);
+        }
+    }
+    async replaceCurrentSession(result, reason, targetSessionReference, withSession) {
+        const previousSession = this.session;
+        try {
+            await previousSession.emitHookSessionEnd(reason === "new" ? "clear" : reason === "resume" ? "resume" : "other");
+            await emitSessionShutdownEvent(previousSession.extensionRunner, {
+                type: "session_shutdown",
+                reason,
+                targetSessionReference,
+                targetSessionFile: targetSessionReference,
+            });
+            await this.flushSession(previousSession);
+            this.beforeSessionInvalidate?.();
+        }
+        catch (error) {
+            await result.session.dispose();
+            throw error;
+        }
+        await previousSession.dispose();
+        this.apply(result);
+        await this.finishSessionReplacement(withSession);
+    }
+    async finishSessionReplacement(withSession) {
+        if (this.rebindSession) {
+            await this.rebindSession(this.session);
+        }
+        if (withSession) {
+            await withSession(this.session.createReplacedSessionContext());
+        }
+    }
+    async switchSession(sessionPath, options) {
+        const beforeResult = await this.emitBeforeSwitch("resume", sessionPath);
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionReference = this.session.sessionReference;
+        const nextSession = await this.sessionManager.openReference(sessionPath, { cwdOverride: options?.cwdOverride });
+        if (this.shouldValidateSessionCwdOnHost()) {
+            assertSessionCwdExists(nextSession, this.services.cwd);
+        }
+        const result = await this.buildAgentSession(nextSession, {
+            type: "session_start",
+            reason: "resume",
+            previousSessionReference,
+            previousSessionFile: previousSessionReference,
+        });
+        await this.replaceCurrentSession(result, "resume", nextSession.getSessionReference(), options?.withSession);
+        return { cancelled: false };
+    }
+    async changeDirectory(cwd) {
+        if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
+            throw new Error(`Directory does not exist: ${cwd}`);
+        }
+        const currentSession = this.session;
+        const persistedSession = currentSession.session;
+        const previousCwd = persistedSession.getCwd();
+        const sessionReference = currentSession.sessionReference;
+        await this.flushSession(currentSession);
+        persistedSession.setCwd(cwd);
+        let result;
+        try {
+            result = await this.buildAgentSession(persistedSession, {
+                type: "session_start",
+                reason: "resume",
+                previousSessionReference: sessionReference,
+                previousSessionFile: sessionReference,
+            });
+        }
+        catch (error) {
+            persistedSession.setCwd(previousCwd);
+            throw error;
+        }
+        try {
+            await this.replaceCurrentSession(result, "resume", sessionReference);
+        }
+        catch (error) {
+            if (this._session === currentSession)
+                persistedSession.setCwd(previousCwd);
+            throw error;
+        }
+        return { cancelled: false };
+    }
+    async newSession(options) {
+        const beforeResult = await this.emitBeforeSwitch("new");
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionReference = this.session.sessionReference;
+        const nextSession = await this.sessionManager.create({
+            id: options?.id,
+            parentSession: options?.parentSession,
+        });
+        if (options?.setup) {
+            await options.setup(nextSession);
+        }
+        const result = await this.buildAgentSession(nextSession, {
+            type: "session_start",
+            reason: "new",
+            previousSessionReference,
+            previousSessionFile: previousSessionReference,
+        });
+        await this.replaceCurrentSession(result, "new", nextSession.getSessionReference(), options?.withSession);
+        return { cancelled: false };
+    }
+    async fork(entryId, options) {
+        const position = options?.position ?? "before";
+        const beforeResult = await this.emitBeforeFork(entryId, { position });
+        if (beforeResult.cancelled) {
+            return { cancelled: true };
+        }
+        let targetLeafId;
+        let selectedText;
+        const activeAgentSession = this.session;
+        const selectedEntry = activeAgentSession.session.getEntry(entryId);
+        if (!selectedEntry) {
+            throw new Error("Invalid entry ID for forking");
+        }
+        if (position === "at") {
+            targetLeafId = selectedEntry.id;
+        }
+        else {
+            if (selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
+                throw new Error("Invalid entry ID for forking");
+            }
+            targetLeafId = selectedEntry.parentId;
+            selectedText = extractUserMessageText(selectedEntry.message.content);
+        }
+        const previousSessionReference = activeAgentSession.sessionReference;
+        const activeSession = activeAgentSession.session;
+        let nextSession;
+        try {
+            nextSession = await activeSession.forkSubSession(targetLeafId);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message === "Session manager unavailable")) {
+                throw error;
+            }
+            nextSession = await this.sessionManager.forkSession(activeSession, targetLeafId);
+        }
+        const result = await this.buildAgentSession(nextSession, {
+            type: "session_start",
+            reason: "fork",
+            previousSessionReference,
+            previousSessionFile: previousSessionReference,
+        });
+        await this.replaceCurrentSession(result, "fork", nextSession.getSessionReference(), options?.withSession);
+        return { cancelled: false, selectedText };
+    }
+    async importFromJsonl(inputPath, cwdOverride) {
+        const resolvedPath = resolve(inputPath);
+        if (!existsSync(resolvedPath)) {
+            throw new SessionImportFileNotFoundError(resolvedPath);
+        }
+        const beforeResult = await this.emitBeforeSwitch("resume", resolvedPath);
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionReference = this.session.sessionReference;
+        const nextSession = await this.sessionManager.importJsonl(resolvedPath, { cwdOverride: cwdOverride });
+        if (this.shouldValidateSessionCwdOnHost()) {
+            assertSessionCwdExists(nextSession, this.services.cwd);
+        }
+        const result = await this.buildAgentSession(nextSession, {
+            type: "session_start",
+            reason: "resume",
+            previousSessionReference,
+            previousSessionFile: previousSessionReference,
+        });
+        await this.replaceCurrentSession(result, "resume", nextSession.getSessionReference());
+        return { cancelled: false };
+    }
+    async runMode(options = {}) {
+        const mode = options.mode ?? this._mode;
+        if (mode === "embedded") {
+            return;
+        }
+        if (mode !== "interactive" && !this.session.model) {
+            console.error(chalk.red(formatNoModelsAvailableMessage()));
+            process.exit(1);
+        }
+        if (options.startupBenchmark && mode !== "interactive") {
+            console.error(chalk.red("Error: GRIP_STARTUP_BENCHMARK only supports interactive mode"));
+            process.exit(1);
+        }
+        if (mode === "rpc") {
+            printTimings();
+            await runRpcMode(this);
+            return;
+        }
+        if (mode === "interactive") {
+            await runInteractiveAppMode(this, this.modelFallbackMessage, options);
+            return;
+        }
+        printTimings();
+        const exitCode = await runPrintMode(this, {
+            mode: mode === "json" ? "json" : "text",
+            messages: options.initialMessages,
+            initialMessage: options.initialMessage,
+            initialImages: options.initialImages,
+        });
+        stopThemeWatcher();
+        restoreStdout();
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
+        }
+    }
+    createSession() {
+        return this.sessionManager.create();
+    }
+    openSessionReference(reference) {
+        return this.sessionManager.openReference(reference);
+    }
+    continueRecentSession() {
+        return this.sessionManager.continueRecent();
+    }
+    forkSessionFrom(reference) {
+        return this.sessionManager.forkFrom(reference);
+    }
+    async listSessions(onProgress) {
+        return this.sessionManager.list(onProgress);
+    }
+    async listAllSessions(onProgress) {
+        return this.sessionManager.listAll(onProgress);
+    }
+    dispose() {
+        this.disposePromise ??= this.disposeRuntime();
+        return this.disposePromise;
+    }
+    async disposeRuntime() {
+        try {
+            if (this._session) {
+                await this.session.emitHookSessionEnd("prompt_input_exit");
+                await emitSessionShutdownEvent(this.session.extensionRunner, {
+                    type: "session_shutdown",
+                    reason: "quit",
+                });
+                await this.flushSession(this.session);
+                this.beforeSessionInvalidate?.();
+                await this.session.dispose();
+                this._session = undefined;
+            }
+        }
+        finally {
+            if (this.options.ownsToolOperations && !this.toolOperationsDisposed) {
+                this.toolOperationsDisposed = true;
+                await this.options.toolOperations?.dispose?.();
+            }
+            for (const cleanup of this.subagentCleanupCallbacks)
+                await cleanup();
+            this.subagentCleanupCallbacks.clear();
+        }
+    }
+}
+//# sourceMappingURL=grip-agent.js.map