@slopus/rig 0.0.4 → 0.0.6

package/dist/server/InMemorySession.js

@@ -1,7 +1,12 @@
 import { createId } from "@paralleldrive/cuid2";
 import { assistantMessageToAgentMessage } from "../agent/assistantMessageToAgentMessage.js";
+import { createGoalContinuationPrompt, normalizeGoalObjective, } from "../goals/index.js";
 import { createCodingAssistantAgent, } from "../app/createCodingAssistantAgent.js";
+import { createCodeReviewPrompt } from "../review/index.js";
+import { mergeMcpTools } from "../mcp/index.js";
+import { DEFAULT_PERMISSION_MODE, parsePermissionMode, } from "../permissions/index.js";
 import { generateSessionTitle } from "./generateSessionTitle.js";
+import { createGoalTitle } from "./createGoalTitle.js";
 import { getProviderIdForModel } from "./getProviderIdForModel.js";
 import { resolveInitialModelSelection } from "./resolveInitialModelSelection.js";
 import { SessionEventLog } from "./SessionEventLog.js";
@@ -14,24 +19,34 @@ export class InMemorySession {
     #agentMetadata;
     #agentId;
     #createEventId;
+    #createRuntime;
+    #contextMessages;
     #draining;
     #effort;
+    #goal;
     #instructions;
     #interruption;
     #lastMessageAt;
     #messages = [];
+    #mcpLoaded = false;
+    #mcpServers = [];
+    #mcpToolProvider;
     #modelCatalog;
     #modelId;
     #models;
+    #nextTaskId = 1;
     #now;
     #partialPositions = new Set();
+    #pendingUserInputs = new Map();
     #persistence;
     #providerId;
+    #permissionMode;
     #queue = [];
     #request;
     #restoredActiveRunId;
     #runtime;
     #status = "idle";
+    #tasks = [];
     #title;
     #titleError;
     #titleStatus = "idle";
@@ -39,7 +54,9 @@ export class InMemorySession {
     constructor(options) {
         this.#agentManager = options.agentManager;
         this.#createEventId = options.createEventId;
+        this.#createRuntime = options.createRuntime ?? createCodingAssistantAgent;
         this.#now = options.now ?? Date.now;
+        this.#mcpToolProvider = options.mcpToolProvider;
         this.#modelCatalog = options.modelCatalog;
         this.#persistence = options.persistence;
         this.#request = { ...options.request };
@@ -60,6 +77,9 @@ export class InMemorySession {
         const selection = resolveInitialModelSelection(this.#modelCatalog, requestedModelId, requestedProviderId);
         this.#modelId = selection.model.id;
         this.#providerId = selection.providerId;
+        this.#permissionMode = parsePermissionMode(options.restore?.permissionMode ??
+            options.request.permissionMode ??
+            DEFAULT_PERMISSION_MODE);
         const requestedEffort = options.restore?.effort ?? options.request.effort;
         this.#effort =
             requestedEffort !== undefined &&
@@ -67,6 +87,11 @@ export class InMemorySession {
                 ? requestedEffort
                 : selection.model.defaultThinkingLevel;
         this.#instructions = options.restore?.instructions ?? options.request.instructions;
+        this.#goal = options.restore?.goal === undefined ? undefined : { ...options.restore.goal };
+        this.#contextMessages =
+            options.restore?.contextMessages === undefined
+                ? undefined
+                : [...options.restore.contextMessages];
         this.#models = this.#modelsForProvider(this.#providerId);
         this.#status = options.restore?.status ?? "idle";
         this.#lastMessageAt = options.restore?.lastMessageAt;
@@ -76,6 +101,9 @@ export class InMemorySession {
         this.#titleStatus =
             options.restore?.titleStatus ??
                 (this.#agentMetadata.description !== undefined ? "ready" : "idle");
+        this.#tasks =
+            options.restore?.tasks === undefined ? [] : options.restore.tasks.map(cloneTask);
+        this.#nextTaskId = options.restore?.nextTaskId ?? nextTaskId(this.#tasks);
         this.#tools = options.restore?.tools ?? [];
         this.#interruption = options.restore?.interruption;
         this.#queue = [...(options.restore?.queuedRuns ?? [])];
@@ -98,6 +126,9 @@ export class InMemorySession {
                 this.emitCreatedEvent();
             }
         }
+        else {
+            this.#continueGoalIfIdle();
+        }
     }
     abort() {
         const runId = this.#activeRun?.runId;
@@ -109,6 +140,7 @@ export class InMemorySession {
             this.#persistence?.deleteQueuedRun(this.id, queued.runId);
         }
         this.#queue = [];
+        this.#pauseActiveGoal();
         this.#activeRun?.controller.abort();
         this.#restoredActiveRunId = undefined;
         void this.#runtime?.processManager.killAll({ forceAfterMs: 500 });
@@ -174,6 +206,234 @@ export class InMemorySession {
         });
         return this.snapshot();
     }
+    changePermissionMode(request) {
+        const permissionMode = parsePermissionMode(request.permissionMode);
+        this.#permissionMode = permissionMode;
+        this.#runtime?.context.permissions?.setMode(permissionMode);
+        this.#append("permission_mode_changed", { permissionMode });
+        return this.snapshot();
+    }
+    setGoal(request) {
+        if (this.isSubagent()) {
+            throw new Error("Goals can only be managed from the primary session.");
+        }
+        if (this.#goal !== undefined && this.#goal.status !== "complete") {
+            throw new Error("This session already has an unfinished goal. Complete or clear it before starting another.");
+        }
+        const now = this.#now();
+        this.#goal = {
+            createdAt: now,
+            objective: normalizeGoalObjective(request.objective),
+            status: "active",
+            updatedAt: now,
+        };
+        this.#lastMessageAt = now;
+        this.#append("goal_changed", { goal: { ...this.#goal } });
+        if (this.#titleStatus === "idle") {
+            this.#title = createGoalTitle(this.#goal.objective);
+            this.#titleStatus = "ready";
+            this.#append("session_title_changed", {
+                status: this.#titleStatus,
+                title: this.#title,
+            });
+        }
+        this.#continueGoalIfIdle();
+        return { ...this.#goal };
+    }
+    changeGoalStatus(request, options = {}) {
+        if (this.isSubagent()) {
+            throw new Error("Goals can only be managed from the primary session.");
+        }
+        if (this.#goal === undefined) {
+            throw new Error("This session does not have a goal.");
+        }
+        if (request.status === "active" && this.#goal.status === "complete") {
+            throw new Error("A completed goal cannot be resumed. Start a new goal instead.");
+        }
+        this.#goal = { ...this.#goal, status: request.status, updatedAt: this.#now() };
+        this.#append("goal_changed", { goal: { ...this.#goal } });
+        if (request.status === "active") {
+            this.#continueGoalIfIdle();
+        }
+        else if (options.stopActiveGoalRun !== false) {
+            this.#discardQueuedGoalRuns();
+            if (this.#activeRun?.kind === "goal") {
+                this.#activeRun.controller.abort();
+                void this.#runtime?.processManager.killAll({ forceAfterMs: 500 });
+            }
+        }
+        return { ...this.#goal };
+    }
+    clearGoal() {
+        if (this.isSubagent()) {
+            throw new Error("Goals can only be managed from the primary session.");
+        }
+        if (this.#goal === undefined)
+            return false;
+        this.#goal = undefined;
+        this.#discardQueuedGoalRuns();
+        if (this.#activeRun?.kind === "goal") {
+            this.#activeRun.controller.abort();
+            void this.#runtime?.processManager.killAll({ forceAfterMs: 500 });
+        }
+        this.#append("goal_changed", { goal: null });
+        return true;
+    }
+    goal() {
+        return this.#goal === undefined ? undefined : { ...this.#goal };
+    }
+    requestUserInput(request, options = {}) {
+        if (this.isSubagent()) {
+            throw new Error("Only the primary session can ask the user a question.");
+        }
+        if (this.#pendingUserInputs.has(request.requestId)) {
+            throw new Error("A user input request with this identifier is already pending.");
+        }
+        if (isSignalAborted(options.signal)) {
+            return Promise.reject(new Error("The user input request was cancelled."));
+        }
+        const response = new Promise((resolve, reject) => {
+            const pending = { request, resolve };
+            if (options.signal !== undefined)
+                pending.signal = options.signal;
+            const onAbort = () => {
+                if (this.#pendingUserInputs.get(request.requestId) !== pending)
+                    return;
+                this.#pendingUserInputs.delete(request.requestId);
+                this.#append("user_input_resolved", {
+                    requestId: request.requestId,
+                    status: "cancelled",
+                });
+                reject(new Error("The user input request was cancelled."));
+            };
+            pending.onAbort = onAbort;
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            this.#pendingUserInputs.set(request.requestId, pending);
+        });
+        this.#append("user_input_requested", request);
+        if (isSignalAborted(options.signal)) {
+            this.#pendingUserInputs.get(request.requestId)?.onAbort?.();
+        }
+        return response;
+    }
+    answerUserInput(requestId, response) {
+        const pending = this.#pendingUserInputs.get(requestId);
+        if (pending === undefined)
+            return undefined;
+        const responseAnswers = response?.answers;
+        if (responseAnswers === null ||
+            typeof responseAnswers !== "object" ||
+            Array.isArray(responseAnswers)) {
+            throw new Error("Choose an answer for every question before continuing.");
+        }
+        const answers = {};
+        for (const question of pending.request.questions) {
+            const selected = responseAnswers[question.id];
+            if (!Array.isArray(selected) ||
+                selected.length === 0 ||
+                selected.some((answer) => typeof answer !== "string" || answer.trim() === "")) {
+                throw new Error(`Answer the ${question.header} question before continuing.`);
+            }
+            if (!question.multiSelect && selected.length > 1) {
+                throw new Error(`Choose one answer for the ${question.header} question.`);
+            }
+            answers[question.id] = [...selected];
+        }
+        this.#pendingUserInputs.delete(requestId);
+        if (pending.onAbort !== undefined) {
+            pending.signal?.removeEventListener("abort", pending.onAbort);
+        }
+        const normalizedResponse = { answers };
+        this.#append("user_input_resolved", {
+            answers,
+            requestId,
+            status: "answered",
+        });
+        pending.resolve(normalizedResponse);
+        return this.snapshot();
+    }
+    createTask(request) {
+        const task = {
+            blockedBy: [],
+            blocks: [],
+            description: request.description,
+            id: String(this.#nextTaskId),
+            status: "pending",
+            subject: request.subject,
+            ...(request.activeForm !== undefined ? { activeForm: request.activeForm } : {}),
+            ...(request.metadata !== undefined ? { metadata: { ...request.metadata } } : {}),
+        };
+        this.#nextTaskId += 1;
+        this.#tasks.push(task);
+        this.#recordTasksChanged();
+        return cloneTask(task);
+    }
+    getTask(taskId) {
+        const task = this.#tasks.find((candidate) => candidate.id === taskId);
+        return task === undefined ? undefined : cloneTask(task);
+    }
+    listTasks() {
+        return this.#tasks.map(cloneTask);
+    }
+    updateTask(taskId, request) {
+        const index = this.#tasks.findIndex((candidate) => candidate.id === taskId);
+        const existing = this.#tasks[index];
+        if (existing === undefined) {
+            return { error: "Task not found", success: false, taskId, updatedFields: [] };
+        }
+        if (request.status === "deleted") {
+            this.#tasks.splice(index, 1);
+            this.#tasks = this.#tasks.map((task) => ({
+                ...task,
+                blockedBy: task.blockedBy.filter((dependency) => dependency !== taskId),
+                blocks: task.blocks.filter((dependency) => dependency !== taskId),
+            }));
+            this.#recordTasksChanged();
+            return {
+                statusChange: { from: existing.status, to: "deleted" },
+                success: true,
+                taskId,
+                updatedFields: ["deleted"],
+            };
+        }
+        const dependencyError = this.#validateTaskDependencies(taskId, request);
+        if (dependencyError !== undefined) {
+            return { error: dependencyError, success: false, taskId, updatedFields: [] };
+        }
+        const task = cloneTask(existing);
+        const updatedFields = [];
+        updateTaskString(task, "subject", request.subject, updatedFields);
+        updateTaskString(task, "description", request.description, updatedFields);
+        updateTaskString(task, "activeForm", request.activeForm, updatedFields);
+        updateTaskString(task, "owner", request.owner, updatedFields);
+        if (request.metadata !== undefined) {
+            const metadata = { ...task.metadata };
+            for (const [key, value] of Object.entries(request.metadata)) {
+                if (value === null)
+                    delete metadata[key];
+                else
+                    metadata[key] = value;
+            }
+            task.metadata = metadata;
+            updatedFields.push("metadata");
+        }
+        let statusChange;
+        if (request.status !== undefined && request.status !== task.status) {
+            statusChange = { from: task.status, to: request.status };
+            task.status = request.status;
+            updatedFields.push("status");
+        }
+        this.#tasks[index] = task;
+        this.#addTaskDependencies(taskId, request, updatedFields);
+        if (updatedFields.length > 0)
+            this.#recordTasksChanged();
+        return {
+            success: true,
+            taskId,
+            updatedFields,
+            ...(statusChange !== undefined ? { statusChange } : {}),
+        };
+    }
     emitCreatedEvent() {
         this.#append("session_created", { session: this.snapshot() });
     }
@@ -185,6 +445,7 @@ export class InMemorySession {
         this.#activeRun = undefined;
         this.#restoredActiveRunId = undefined;
         this.#activePartial = undefined;
+        this.#pauseActiveGoal();
         const interruptedRunIds = [
             ...(interruption.runId !== undefined ? [interruption.runId] : []),
             ...this.#queue.map((queued) => queued.runId),
@@ -212,12 +473,39 @@ export class InMemorySession {
         this.#interruption = undefined;
         this.#restoredActiveRunId = undefined;
         this.#messages = [];
+        this.#contextMessages = undefined;
         this.#partialPositions.clear();
         this.#activePartial = undefined;
+        const hadTasks = this.#tasks.length > 0;
+        const hadGoal = this.#goal !== undefined;
+        this.#goal = undefined;
+        this.#tasks = [];
+        this.#nextTaskId = 1;
         this.#persistence?.clearMessages(this.id);
+        if (hadTasks)
+            this.#recordTasksChanged();
+        if (hadGoal)
+            this.#append("goal_changed", { goal: null });
         this.#append("session_reset", { snapshot: this.#agentSnapshot() });
         return this.snapshot();
     }
+    async compact(signal) {
+        if (this.#activeRun !== undefined || this.#queue.length > 0) {
+            throw new Error("Wait for the active response to finish before compacting.");
+        }
+        const previousStatus = this.#status;
+        this.#status = "running";
+        this.#saveSession();
+        try {
+            const result = await this.#ensureRuntime().agent.compact(signal);
+            this.#syncContextMessages();
+            return result;
+        }
+        finally {
+            this.#status = previousStatus;
+            this.#saveSession();
+        }
+    }
     isSubagent() {
         return this.#agentMetadata.type === "subagent";
     }
@@ -231,6 +519,7 @@ export class InMemorySession {
             ...(this.#instructions !== undefined ? { instructions: this.#instructions } : {}),
             modelId: this.#modelId,
             ...(this.#request.apiKey !== undefined ? { apiKey: this.#request.apiKey } : {}),
+            permissionMode: this.#permissionMode,
         };
     }
     snapshot() {
@@ -241,6 +530,7 @@ export class InMemorySession {
             agentId: this.#agentId,
             cwd: this.#request.cwd,
             providerId: this.#providerId,
+            permissionMode: this.#permissionMode,
             modelId: this.#modelId,
             modelLocked: this.#modelLocked(),
             models: this.#models,
@@ -248,6 +538,10 @@ export class InMemorySession {
             snapshot,
             titleStatus: this.#titleStatus,
             agent: this.agentMetadata(),
+            pendingUserInputs: [...this.#pendingUserInputs.values()].map((pending) => pending.request),
+            mcpServers: this.#mcpServers,
+            tasks: this.listTasks(),
+            ...(this.#goal !== undefined ? { goal: { ...this.#goal } } : {}),
             ...(snapshot.effort !== undefined ? { effort: snapshot.effort } : {}),
             ...(this.#title !== undefined ? { title: this.#title } : {}),
             ...(this.#titleError !== undefined ? { titleError: this.#titleError } : {}),
@@ -260,6 +554,7 @@ export class InMemorySession {
             id: this.id,
             cwd: this.#request.cwd,
             providerId: this.#providerId,
+            permissionMode: this.#permissionMode,
             modelId: this.#modelId,
             ...(this.#effort !== undefined ? { effort: this.#effort } : {}),
             status: this.#status,
@@ -274,21 +569,33 @@ export class InMemorySession {
     }
     state() {
         const activeRunId = this.#activeRun?.runId ?? this.#restoredActiveRunId;
+        const runtimeSnapshot = this.#runtime?.agent.snapshot();
+        const contextMessages = runtimeSnapshot?.contextMessages === undefined
+            ? this.#contextMessages
+            : [
+                ...runtimeSnapshot.contextMessages,
+                ...runtimeSnapshot.queue.map((queued) => queued.message),
+            ];
         const state = {
             agent: this.agentMetadata(),
             agentId: this.#agentId,
             cwd: this.#request.cwd,
+            ...(contextMessages !== undefined ? { contextMessages: [...contextMessages] } : {}),
             ...(this.#effort !== undefined ? { effort: this.#effort } : {}),
             id: this.id,
             ...(this.#instructions !== undefined ? { instructions: this.#instructions } : {}),
+            ...(this.#goal !== undefined ? { goal: { ...this.#goal } } : {}),
             ...(this.#interruption !== undefined ? { interruption: this.#interruption } : {}),
             ...(this.#lastMessageAt !== undefined ? { lastMessageAt: this.#lastMessageAt } : {}),
             messages: [...this.#messages],
             modelId: this.#modelId,
             models: this.#models,
             providerId: this.#providerId,
+            permissionMode: this.#permissionMode,
             queuedRuns: [...this.#queue],
+            nextTaskId: this.#nextTaskId,
             status: this.#status,
+            tasks: this.listTasks(),
             ...(this.#title !== undefined ? { title: this.#title } : {}),
             ...(this.#titleError !== undefined ? { titleError: this.#titleError } : {}),
             titleStatus: this.#titleStatus,
@@ -303,15 +610,25 @@ export class InMemorySession {
         const runId = createId();
         const displayText = request.displayText ?? request.text;
         const blocks = request.content ?? [
-            { type: "text", text: request.text },
+            { type: "text", text: createCodeReviewPrompt(request.text) ?? request.text },
         ];
         const userMessage = {
             role: "user",
             id: createId(),
             blocks,
         };
+        const visibleMessage = {
+            role: "user",
+            id: userMessage.id,
+            blocks: blocks.some((block) => block.type === "image")
+                ? blocks
+                : displayText.length > 0
+                    ? [{ type: "text", text: displayText }]
+                    : [],
+        };
         const queued = {
             displayText,
+            kind: "user",
             runId,
             text: request.text,
             userMessage,
@@ -321,10 +638,11 @@ export class InMemorySession {
         this.#persistence?.insertQueuedRun(this.id, queued);
         this.#status = this.#activeRun === undefined ? "queued" : "running";
         this.#lastMessageAt = this.#now();
-        this.#storeMessage(this.#messages.length, userMessage, false, runId);
+        this.#separateModelContextFromVisibleTranscript();
+        this.#storeMessage(this.#messages.length, visibleMessage, false, runId);
         const event = this.#append("message_submitted", {
             displayText,
-            message: userMessage,
+            message: visibleMessage,
             runId,
         });
         this.#startTitleGeneration(request.text);
@@ -335,6 +653,39 @@ export class InMemorySession {
             sessionId: this.id,
         };
     }
+    steer(request) {
+        const activeRun = this.#activeRun;
+        if (activeRun === undefined) {
+            throw new Error("There is no active run to steer.");
+        }
+        const displayText = request.displayText ?? request.text;
+        const blocks = request.content ?? [
+            { type: "text", text: request.text },
+        ];
+        const userMessage = {
+            role: "user",
+            id: createId(),
+            blocks,
+        };
+        const agent = this.#ensureRuntime().agent;
+        if (agent.status === "running")
+            agent.steerMessage(userMessage);
+        else
+            agent.enqueueMessage(userMessage);
+        this.#interruption = undefined;
+        this.#lastMessageAt = this.#now();
+        this.#storeMessage(this.#messages.length, userMessage, false, activeRun.runId);
+        const event = this.#append("message_submitted", {
+            displayText,
+            message: userMessage,
+            runId: activeRun.runId,
+        });
+        return {
+            eventId: event.id,
+            runId: activeRun.runId,
+            sessionId: this.id,
+        };
+    }
     subagentSummary() {
         if (this.#agentMetadata.type !== "subagent" ||
             this.#agentMetadata.parentSessionId === undefined) {
@@ -352,6 +703,9 @@ export class InMemorySession {
                 ? { parentToolCallId: this.#agentMetadata.parentToolCallId }
                 : {}),
             status: this.#status,
+            ...(this.#agentMetadata.taskName !== undefined
+                ? { taskName: this.#agentMetadata.taskName }
+                : {}),
             updatedAt: this.events.lastCreatedAt() ?? this.#now(),
         };
     }
@@ -386,6 +740,13 @@ export class InMemorySession {
             queue: runtimeSnapshot?.queue ?? [],
             tools: this.#tools,
             ...(this.#effort !== undefined ? { effort: this.#effort } : {}),
+            ...((runtimeSnapshot?.contextMessages ?? this.#contextMessages) !== undefined
+                ? {
+                    contextMessages: [
+                        ...(runtimeSnapshot?.contextMessages ?? this.#contextMessages ?? []),
+                    ],
+                }
+                : {}),
             ...(this.#instructions !== undefined ? { instructions: this.#instructions } : {}),
             ...(runtimeSnapshot?.lastRunId !== undefined
                 ? { lastRunId: runtimeSnapshot.lastRunId }
@@ -401,6 +762,65 @@ export class InMemorySession {
         }
         return "idle";
     }
+    #validateTaskDependencies(taskId, request) {
+        for (const dependency of [...(request.addBlocks ?? []), ...(request.addBlockedBy ?? [])]) {
+            if (dependency === taskId)
+                return "A task cannot depend on itself.";
+            if (!this.#tasks.some((task) => task.id === dependency)) {
+                return `Task ${dependency} was not found.`;
+            }
+        }
+        return undefined;
+    }
+    #addTaskDependencies(taskId, request, updatedFields) {
+        const task = this.#tasks.find((candidate) => candidate.id === taskId);
+        if (task === undefined)
+            return;
+        for (const blockedTaskId of request.addBlocks ?? []) {
+            const blockedTask = this.#tasks.find((candidate) => candidate.id === blockedTaskId);
+            if (blockedTask === undefined)
+                continue;
+            if (!task.blocks.includes(blockedTaskId)) {
+                task.blocks = [...task.blocks, blockedTaskId];
+                pushUnique(updatedFields, "blocks");
+            }
+            if (!blockedTask.blockedBy.includes(taskId)) {
+                blockedTask.blockedBy = [...blockedTask.blockedBy, taskId];
+            }
+        }
+        for (const blockingTaskId of request.addBlockedBy ?? []) {
+            const blockingTask = this.#tasks.find((candidate) => candidate.id === blockingTaskId);
+            if (blockingTask === undefined)
+                continue;
+            if (!task.blockedBy.includes(blockingTaskId)) {
+                task.blockedBy = [...task.blockedBy, blockingTaskId];
+                pushUnique(updatedFields, "blockedBy");
+            }
+            if (!blockingTask.blocks.includes(taskId)) {
+                blockingTask.blocks = [...blockingTask.blocks, taskId];
+            }
+        }
+    }
+    #recordTasksChanged() {
+        this.#append("tasks_changed", { tasks: this.listTasks() });
+    }
+    async #ensureMcpTools(runtime) {
+        if (this.#mcpLoaded)
+            return;
+        if (this.#mcpToolProvider === undefined) {
+            this.#mcpLoaded = true;
+            return;
+        }
+        const loaded = await this.#mcpToolProvider.load(this.#request.cwd);
+        const merged = mergeMcpTools(runtime.agent.tools, loaded);
+        runtime.agent.setTools(merged.tools);
+        this.#tools = runtime.agent.tools.map((tool) => tool.name);
+        this.#mcpServers = merged.servers;
+        this.#mcpLoaded = true;
+        if (merged.servers.length > 0) {
+            this.#append("mcp_servers_changed", { servers: merged.servers });
+        }
+    }
     #append(type, data) {
         const event = {
             createdAt: this.#now(),
@@ -478,24 +898,48 @@ export class InMemorySession {
             cwd: this.#request.cwd,
             messages: this.#committedMessages(),
             modelId: this.#modelId,
+            permissionMode: this.#permissionMode,
             providerId: this.#providerId,
+            userInput: {
+                request: (request, requestOptions) => this.requestUserInput(request, requestOptions),
+            },
+            tasks: {
+                create: (request) => this.#taskSession().createTask(request),
+                get: (taskId) => this.#taskSession().getTask(taskId),
+                list: () => this.#taskSession().listTasks(),
+                update: (taskId, request) => this.#taskSession().updateTask(taskId, request),
+            },
         };
+        if (!this.isSubagent()) {
+            options.goals = {
+                create: (request) => this.setGoal(request),
+                get: () => this.goal(),
+                update: (status) => this.changeGoalStatus({ status }, { stopActiveGoalRun: false }),
+            };
+        }
+        if (this.#contextMessages !== undefined) {
+            options.contextMessages = this.#contextMessages;
+        }
         if (this.#effort !== undefined)
             options.effort = this.#effort;
         if (this.#instructions !== undefined)
             options.instructions = this.#instructions;
         if (this.#request.apiKey !== undefined)
             options.apiKey = this.#request.apiKey;
-        if (this.#agentManager !== undefined) {
+        const agentManager = this.#agentManager;
+        if (agentManager !== undefined) {
             options.subagents = {
-                canSpawn: this.#agentMetadata.depth < this.#agentManager.maxDepth,
+                canSpawn: this.#agentMetadata.depth < agentManager.maxDepth,
                 depth: this.#agentMetadata.depth,
-                maxDepth: this.#agentManager.maxDepth,
-                spawn: (request, signal) => this.#agentManager?.spawn(this.id, request, signal) ??
-                    Promise.reject(new Error("Subagent management is unavailable.")),
+                followUp: (target, message) => agentManager.followUp(this.id, target, message),
+                interrupt: (target) => agentManager.interrupt(this.id, target),
+                list: (pathPrefix) => agentManager.list(this.id, pathPrefix),
+                maxDepth: agentManager.maxDepth,
+                spawn: (request, signal) => agentManager.spawn(this.id, request, signal),
+                wait: (timeoutMs, signal) => agentManager.wait(this.id, timeoutMs, signal),
             };
         }
-        const runtime = createCodingAssistantAgent(options);
+        const runtime = this.#createRuntime(options);
         const snapshot = runtime.agent.snapshot();
         this.#runtime = runtime;
         this.#agentId = snapshot.id;
@@ -508,6 +952,9 @@ export class InMemorySession {
         this.#saveSession();
         return runtime;
     }
+    #taskSession() {
+        return this.#agentManager?.taskSession(this.id) ?? this;
+    }
     async #drainQueue() {
         for (;;) {
             const queued = this.#queue.shift();
@@ -525,6 +972,16 @@ export class InMemorySession {
     #saveSession() {
         this.#persistence?.saveSession(this.state());
     }
+    #separateModelContextFromVisibleTranscript() {
+        if (this.#contextMessages !== undefined)
+            return;
+        const runtimeSnapshot = this.#runtime?.agent.snapshot();
+        this.#contextMessages = [
+            ...(runtimeSnapshot?.contextMessages ??
+                runtimeSnapshot?.messages ??
+                this.#committedMessages()),
+        ];
+    }
     #completionForRun(runId) {
         const events = this.events.since(undefined) ?? [];
         for (let index = events.length - 1; index >= 0; index -= 1) {
@@ -592,13 +1049,18 @@ export class InMemorySession {
     }
     async #runQueued(queued) {
         const controller = new AbortController();
-        this.#activeRun = { controller, runId: queued.runId };
+        this.#activeRun = { controller, kind: queued.kind, runId: queued.runId };
         this.#restoredActiveRunId = undefined;
         this.#status = "running";
         this.#append("run_started", { runId: queued.runId });
         try {
             const runtime = this.#ensureRuntime();
+            await this.#ensureMcpTools(runtime);
             runtime.agent.enqueueMessage(queued.userMessage);
+            if (this.#contextMessages !== undefined) {
+                this.#contextMessages = [...this.#contextMessages, queued.userMessage];
+                this.#saveSession();
+            }
             const result = await runtime.agent.run({
                 signal: controller.signal,
                 onEvent: (event) => this.#appendAgentEvent(queued.runId, event),
@@ -608,6 +1070,9 @@ export class InMemorySession {
                 return;
             }
             this.#appendRunFinished(queued.runId, result);
+            if (result.stopReason !== "aborted" && result.stopReason !== "error") {
+                this.#continueGoalIfIdle();
+            }
         }
         catch (error) {
             if (this.#activeRun?.runId !== queued.runId) {
@@ -615,6 +1080,7 @@ export class InMemorySession {
             }
             this.#status = "error";
             this.#activePartial = undefined;
+            this.#pauseActiveGoal();
             if (this.#activeRun?.runId === queued.runId) {
                 this.#activeRun = undefined;
             }
@@ -627,9 +1093,16 @@ export class InMemorySession {
             if (this.#activeRun?.runId === queued.runId) {
                 this.#activeRun = undefined;
             }
+            this.#syncContextMessages();
             this.#saveSession();
         }
     }
+    #syncContextMessages() {
+        const snapshot = this.#runtime?.agent.snapshot();
+        if (snapshot !== undefined) {
+            this.#contextMessages = [...(snapshot.contextMessages ?? snapshot.messages)];
+        }
+    }
     #startDrainQueue() {
         if (this.#draining !== undefined) {
             return;
@@ -638,6 +1111,54 @@ export class InMemorySession {
             this.#draining = undefined;
         });
     }
+    #continueGoalIfIdle() {
+        if (this.isSubagent() ||
+            this.#goal?.status !== "active" ||
+            this.#restoredActiveRunId !== undefined ||
+            this.#status === "running" ||
+            this.#activeRun !== undefined ||
+            this.#queue.length > 0) {
+            return;
+        }
+        const runId = createId();
+        const text = createGoalContinuationPrompt(this.#goal);
+        const userMessage = {
+            blocks: [{ type: "text", text }],
+            id: createId(),
+            role: "user",
+        };
+        const queued = {
+            displayText: "Continuing active goal",
+            kind: "goal",
+            runId,
+            text,
+            userMessage,
+        };
+        this.#queue.push(queued);
+        this.#persistence?.insertQueuedRun(this.id, queued);
+        this.#status = "queued";
+        this.#saveSession();
+        this.#startDrainQueue();
+    }
+    #discardQueuedGoalRuns() {
+        const goalRunIds = this.#queue
+            .filter((queued) => queued.kind === "goal")
+            .map((queued) => queued.runId);
+        if (goalRunIds.length === 0)
+            return;
+        this.#queue = this.#queue.filter((queued) => queued.kind !== "goal");
+        for (const runId of goalRunIds)
+            this.#persistence?.deleteQueuedRun(this.id, runId);
+        if (this.#activeRun === undefined && this.#queue.length === 0)
+            this.#status = "idle";
+        this.#saveSession();
+    }
+    #pauseActiveGoal() {
+        if (this.#goal?.status !== "active")
+            return;
+        this.#goal = { ...this.#goal, status: "paused", updatedAt: this.#now() };
+        this.#append("goal_changed", { goal: { ...this.#goal } });
+    }
     #storeMessage(position, message, isPartial, runId) {
         const entry = {
             isPartial,
@@ -674,3 +1195,30 @@ export class InMemorySession {
         this.#storeMessage(position, message, true, runId);
     }
 }
+function isSignalAborted(signal) {
+    return signal?.aborted === true;
+}
+function cloneTask(task) {
+    return {
+        ...task,
+        blockedBy: [...task.blockedBy],
+        blocks: [...task.blocks],
+        ...(task.metadata !== undefined ? { metadata: { ...task.metadata } } : {}),
+    };
+}
+function nextTaskId(tasks) {
+    return (tasks.reduce((highest, task) => {
+        const value = Number.parseInt(task.id, 10);
+        return Number.isSafeInteger(value) ? Math.max(highest, value) : highest;
+    }, 0) + 1);
+}
+function updateTaskString(task, key, value, updatedFields) {
+    if (value === undefined || task[key] === value)
+        return;
+    task[key] = value;
+    updatedFields.push(key);
+}
+function pushUnique(values, value) {
+    if (!values.includes(value))
+        values.push(value);
+}