@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-1

package/LICENSE

@@ -25,4 +25,4 @@ SOFTWARE.
 Publicis Sapient. Licensing for these portions is to be determined.
 Until then, no license is granted to use, copy, modify, or redistribute
 the @psnext-authored portions beyond what npm's distribution model implies.
-The bundled @mariozechner/pi-* code remains under the MIT license above.
+The bundled @earendil-works/pi-* code remains under the MIT license above.

package/README.md

@@ -103,4 +103,4 @@ rm -rf ~/.sling
 
 Licensing for `@psnext/slingcli` is to be determined.
 
-This package bundles `@mariozechner/pi-*` (MIT, © 2025 Mario Zechner). The upstream MIT license is preserved in the `LICENSE` file.
+This package bundles `@earendil-works/pi-*` (MIT, © 2025 Mario Zechner). The upstream MIT license is preserved in the `LICENSE` file.

package/bin/sling.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-process.title = "sling";
+process.title = "⭕️ sling";
 
-const SLING_VERSION = "2.4.20260507-3";
+const SLING_VERSION = "2.4.20260509-1";
 
-import { setBedrockProviderModule } from "@mariozechner/pi-ai";
-import { bedrockProviderModule } from "@mariozechner/pi-ai/bedrock-provider";
+import { setBedrockProviderModule } from "@earendil-works/pi-ai";
+import { bedrockProviderModule } from "@earendil-works/pi-ai/bedrock-provider";
 import { EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
-import { main } from "@mariozechner/pi-coding-agent";
+import { main } from "@earendil-works/pi-coding-agent";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -70,9 +70,9 @@ async function checkAndInstallPackages() {
     const packages = config.packages || [];
     if (packages.length === 0) return;
 
-    console.log("\nFirst run detected. Installing default packages...");
+    console.log("\\nFirst run detected. Installing default packages...");
     for (const pkg of packages) {
-      console.log(`Installing ${pkg}...`);
+      console.log(`Installing \${pkg}...`);
       try {
         await runCommand(process.execPath, [__filename, "install", pkg]);
         console.log(`✓ Installed ${pkg}`);
@@ -82,7 +82,7 @@ async function checkAndInstallPackages() {
       }
     }
     writeFileSync(markerFile, new Date().toISOString());
-    console.log("\nDefault packages installation complete!\n");
+    console.log("\\nDefault packages installation complete!\\n");
   } catch (err) {
     console.error("Failed to read default packages config:", err.message);
   }
@@ -132,18 +132,18 @@ async function checkForUpdate(args) {
   console.log("Installing @psnext/slingcli@" + latestVersion + "...");
   try {
     await runCommand("npm", ["install", "-g", "@psnext/slingcli@latest"]);
-    console.log("\u2713 Updated to " + latestVersion + ". Please run 'sling' again.");
+    console.log("\\u2713 Updated to " + latestVersion + ". Please run 'sling' again.");
     process.exit(0);
   } catch {
-    console.error("\u2717 Auto-update failed. Run manually:");
+    console.error("\\u2717 Auto-update failed. Run manually:");
     console.error("  npm install -g @psnext/slingcli@latest");
     console.error("  (you may need sudo)");
   }
 }
 
-//  defaults to global (~/.sling/agent). When run from a
+// \`sling install <pkg>\` defaults to global (~/.sling/agent). When run from a
 // TTY without an explicit scope flag, prompt for global vs local. Pi has no
-//  flag because global is its default; we only inject  when
+// \`-g/--global\` flag because global is its default; we only inject \`-l\` when
 // the user picks local. Non-TTY (CI/scripts) keeps the current default.
 async function promptInstallScopeIfNeeded(args) {
   let isInstall = false;

package/node_modules/@aws-sdk/client-bedrock-runtime/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-bedrock-runtime",
   "description": "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-  "version": "3.1044.0",
+  "version": "3.1045.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",
@@ -39,7 +39,7 @@
     "@aws-sdk/middleware-user-agent": "^3.972.38",
     "@aws-sdk/middleware-websocket": "^3.972.16",
     "@aws-sdk/region-config-resolver": "^3.972.13",
-    "@aws-sdk/token-providers": "3.1044.0",
+    "@aws-sdk/token-providers": "3.1045.0",
     "@aws-sdk/types": "^3.973.8",
     "@aws-sdk/util-endpoints": "^3.996.8",
     "@aws-sdk/util-user-agent-browser": "^3.972.10",

package/node_modules/@aws-sdk/token-providers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/token-providers",
-  "version": "3.1044.0",
+  "version": "3.1045.0",
   "description": "A collection of token providers",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",

package/node_modules/{@mariozechner → @earendil-works}/pi-agent-core/dist/agent-loop.js

@@ -2,7 +2,7 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { EventStream, streamSimple, validateToolArguments, } from "@mariozechner/pi-ai";
+import { EventStream, streamSimple, validateToolArguments, } from "@earendil-works/pi-ai";
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.

package/node_modules/{@mariozechner → @earendil-works}/pi-agent-core/dist/agent.js

@@ -1,4 +1,4 @@
-import { streamSimple, } from "@mariozechner/pi-ai";
+import { streamSimple, } from "@earendil-works/pi-ai";
 import { runAgentLoop, runAgentLoopContinue } from "./agent-loop.js";
 function defaultConvertToLlm(messages) {
     return messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
@@ -335,8 +335,9 @@ export class Agent {
             errorMessage: error instanceof Error ? error.message : String(error),
             timestamp: Date.now(),
         };
-        this._state.messages.push(failureMessage);
-        this._state.errorMessage = failureMessage.errorMessage;
+        await this.processEvents({ type: "message_start", message: failureMessage });
+        await this.processEvents({ type: "message_end", message: failureMessage });
+        await this.processEvents({ type: "turn_end", message: failureMessage, toolResults: [] });
         await this.processEvents({ type: "agent_end", messages: [failureMessage] });
     }
     finishRun() {

package/node_modules/@earendil-works/pi-agent-core/dist/harness/agent-harness.js

@@ -0,0 +1,526 @@
+import { randomUUID } from "node:crypto";
+import { Agent } from "../agent.js";
+import { collectEntriesForBranchSummary, generateBranchSummary } from "./compaction/branch-summarization.js";
+import { compact, DEFAULT_COMPACTION_SETTINGS, prepareCompaction } from "./compaction/compaction.js";
+import { expandPromptTemplate } from "./prompt-templates.js";
+import { expandSkillCommand } from "./skills.js";
+function createUserMessage(text, images) {
+    const content = [{ type: "text", text }];
+    if (images)
+        content.push(...images);
+    return { role: "user", content, timestamp: Date.now() };
+}
+export class AgentHarness {
+    agent;
+    env;
+    conversation;
+    operation;
+    session;
+    resourcesInput;
+    systemPrompt;
+    requestAuth;
+    toolRegistry = new Map();
+    listeners = new Set();
+    hooks = new Map();
+    constructor(options) {
+        this.agent = new Agent({
+            initialState: {
+                model: options.model,
+                thinkingLevel: options.thinkingLevel,
+                tools: options.tools ?? [],
+            },
+        });
+        this.env = options.env;
+        this.session = options.session;
+        this.resourcesInput = options.resources;
+        this.systemPrompt = options.systemPrompt;
+        this.requestAuth = options.requestAuth;
+        for (const tool of this.agent.state.tools) {
+            this.toolRegistry.set(tool.name, tool);
+        }
+        this.conversation = {
+            session: options.session,
+            model: options.model,
+            thinkingLevel: options.thinkingLevel ?? this.agent.state.thinkingLevel,
+            activeToolNames: options.activeToolNames ?? this.agent.state.tools.map((tool) => tool.name),
+            nextTurnQueue: [],
+        };
+        this.agent.state.model = this.conversation.model;
+        this.agent.state.thinkingLevel = this.conversation.thinkingLevel;
+        this.agent.getApiKey = async (provider) => {
+            const model = this.conversation.model;
+            if (!this.requestAuth || model.provider !== provider)
+                return undefined;
+            return (await this.requestAuth(model))?.apiKey;
+        };
+        this.operation = {
+            idle: true,
+            abortRequested: false,
+            steerQueue: [],
+            followUpQueue: [],
+            pendingMutations: {
+                appendMessages: [],
+            },
+        };
+        this.agent.transformContext = async (messages, signal) => {
+            const result = await this.emitHook("context", { type: "context", messages: [...messages] }, signal);
+            return result?.messages ?? messages;
+        };
+        this.agent.beforeToolCall = async ({ toolCall, args }, signal) => {
+            const result = await this.emitHook("tool_call", {
+                type: "tool_call",
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
+                input: args,
+            }, signal);
+            return result ? { block: result.block, reason: result.reason } : undefined;
+        };
+        this.agent.afterToolCall = async ({ toolCall, args, result, isError }, signal) => {
+            const patch = await this.emitHook("tool_result", {
+                type: "tool_result",
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
+                input: args,
+                content: result.content,
+                details: result.details,
+                isError,
+            }, signal);
+            return patch
+                ? { content: patch.content, details: patch.details, isError: patch.isError, terminate: patch.terminate }
+                : undefined;
+        };
+        this.agent.onPayload = async (payload) => {
+            const result = await this.emitHook("before_provider_request", { type: "before_provider_request", payload });
+            return result?.payload ?? payload;
+        };
+        this.agent.onResponse = async (response) => {
+            const headers = { ...response.headers };
+            await this.emitOwn({ type: "after_provider_response", status: response.status, headers }, this.agent.signal);
+        };
+        this.agent.subscribe(async (event, signal) => {
+            await this.handleAgentEvent(event, signal);
+        });
+        void this.syncFromTree();
+    }
+    createContext(signal) {
+        return {
+            env: this.env,
+            conversation: this.conversation,
+            operation: this.operation,
+            abortSignal: signal,
+        };
+    }
+    async resolveResources(signal) {
+        return typeof this.resourcesInput === "function"
+            ? await this.resourcesInput(this.createContext(signal))
+            : (this.resourcesInput ?? {});
+    }
+    getActiveTools() {
+        return this.conversation.activeToolNames
+            .map((name) => this.toolRegistry.get(name))
+            .filter((tool) => tool !== undefined);
+    }
+    async resolveSystemPrompt(resources) {
+        if (!this.systemPrompt)
+            return "You are a helpful assistant.";
+        if (typeof this.systemPrompt === "string")
+            return this.systemPrompt;
+        return await this.systemPrompt({
+            env: this.env,
+            session: this.session,
+            model: this.conversation.model,
+            thinkingLevel: this.conversation.thinkingLevel,
+            activeTools: this.getActiveTools(),
+            resources,
+        });
+    }
+    async emitOwn(event, signal) {
+        for (const listener of this.listeners) {
+            await listener(event, signal);
+        }
+    }
+    async emitAny(event, signal) {
+        for (const listener of this.listeners) {
+            await listener(event, signal);
+        }
+    }
+    async emitHook(type, event, signal) {
+        const handlers = this.hooks.get(type);
+        if (!handlers || handlers.size === 0)
+            return undefined;
+        let lastResult;
+        for (const handler of handlers) {
+            const result = await handler(event, this.createContext(signal));
+            if (result !== undefined) {
+                lastResult = result;
+            }
+        }
+        return lastResult;
+    }
+    async emitQueueUpdate() {
+        await this.emitOwn({
+            type: "queue_update",
+            steer: [...this.operation.steerQueue],
+            followUp: [...this.operation.followUpQueue],
+            nextTurn: [...this.conversation.nextTurnQueue],
+        });
+    }
+    async syncFromTree() {
+        const context = await this.session.buildContext();
+        this.agent.state.messages = context.messages;
+        if (context.model && this.conversation.model) {
+            // leave active model untouched; harness-level model is source of truth
+        }
+        this.agent.state.systemPrompt = await this.resolveSystemPrompt(await this.resolveResources());
+    }
+    async applyPendingMutations() {
+        for (const message of this.operation.pendingMutations.appendMessages) {
+            await this.session.appendMessage(message);
+        }
+        this.operation.pendingMutations.appendMessages = [];
+        if (this.operation.pendingMutations.model) {
+            const model = this.operation.pendingMutations.model;
+            const previousModel = this.conversation.model;
+            this.conversation.model = model;
+            this.agent.state.model = model;
+            await this.session.appendModelChange(model.provider, model.id);
+            await this.emitOwn({ type: "model_select", model, previousModel, source: "set" });
+            this.operation.pendingMutations.model = undefined;
+        }
+        if (this.operation.pendingMutations.thinkingLevel !== undefined) {
+            const level = this.operation.pendingMutations.thinkingLevel;
+            const previousLevel = this.conversation.thinkingLevel;
+            this.conversation.thinkingLevel = level;
+            this.agent.state.thinkingLevel = level;
+            await this.session.appendThinkingLevelChange(level);
+            await this.emitOwn({ type: "thinking_level_select", level, previousLevel });
+            this.operation.pendingMutations.thinkingLevel = undefined;
+        }
+        if (this.operation.pendingMutations.activeToolNames) {
+            this.conversation.activeToolNames = [...this.operation.pendingMutations.activeToolNames];
+            this.agent.state.tools = this.conversation.activeToolNames
+                .map((name) => this.toolRegistry.get(name))
+                .filter((tool) => tool !== undefined);
+            this.operation.pendingMutations.activeToolNames = undefined;
+        }
+        await this.syncFromTree();
+    }
+    async handleAgentEvent(event, signal) {
+        await this.emitAny(event, signal);
+        if (event.type === "message_start") {
+            const steerIndex = this.operation.steerQueue.indexOf(event.message);
+            if (steerIndex !== -1) {
+                this.operation.steerQueue.splice(steerIndex, 1);
+                await this.emitQueueUpdate();
+            }
+            else {
+                const followUpIndex = this.operation.followUpQueue.indexOf(event.message);
+                if (followUpIndex !== -1) {
+                    this.operation.followUpQueue.splice(followUpIndex, 1);
+                    await this.emitQueueUpdate();
+                }
+            }
+        }
+        if (event.type === "message_end") {
+            await this.session.appendMessage(event.message);
+        }
+        if (event.type === "turn_end") {
+            const hadPendingMutations = this.operation.pendingMutations.appendMessages.length > 0 ||
+                this.operation.pendingMutations.model !== undefined ||
+                this.operation.pendingMutations.thinkingLevel !== undefined ||
+                this.operation.pendingMutations.activeToolNames !== undefined;
+            await this.emitOwn({ type: "save_point", liveOperationId: this.operation.liveOperationId ?? "unknown", hadPendingMutations }, signal);
+            if (hadPendingMutations) {
+                await this.applyPendingMutations();
+            }
+        }
+        if (event.type === "agent_end") {
+            this.operation.idle = true;
+            this.operation.liveOperationId = undefined;
+            this.operation.abortRequested = false;
+            await this.syncFromTree();
+            await this.emitOwn({ type: "settled", nextTurnCount: this.conversation.nextTurnQueue.length }, signal);
+        }
+    }
+    async prompt(text, options) {
+        if (!this.operation.idle)
+            throw new Error("AgentHarness is busy");
+        const beforeLength = this.agent.state.messages.length;
+        this.operation.idle = false;
+        this.operation.liveOperationId = randomUUID();
+        const resources = await this.resolveResources(this.agent.signal);
+        let messages = [createUserMessage(text, options?.images)];
+        if (this.conversation.nextTurnQueue.length > 0) {
+            messages = [messages[0], ...this.conversation.nextTurnQueue];
+            this.conversation.nextTurnQueue = [];
+            await this.emitQueueUpdate();
+        }
+        this.agent.state.systemPrompt = await this.resolveSystemPrompt(resources);
+        const beforeResult = await this.emitHook("before_agent_start", {
+            type: "before_agent_start",
+            prompt: text,
+            images: options?.images,
+            systemPrompt: this.agent.state.systemPrompt,
+            resources,
+        }, this.agent.signal);
+        if (beforeResult?.messages)
+            messages = [...beforeResult.messages, ...messages];
+        if (beforeResult?.systemPrompt)
+            this.agent.state.systemPrompt = beforeResult.systemPrompt;
+        await this.agent.prompt(messages);
+        let response;
+        const newMessages = this.agent.state.messages.slice(beforeLength);
+        for (let i = newMessages.length - 1; i >= 0; i--) {
+            const message = newMessages[i];
+            if (message.role === "assistant") {
+                response = message;
+                break;
+            }
+        }
+        if (!response)
+            throw new Error("AgentHarness prompt completed without an assistant message");
+        return response;
+    }
+    async skill(name, additionalInstructions) {
+        const resources = await this.resolveResources();
+        const skill = (resources.skills ?? []).find((candidate) => candidate.name === name);
+        if (!skill)
+            throw new Error(`Unknown skill: ${name}`);
+        return await this.prompt(expandSkillCommand(skill, additionalInstructions));
+    }
+    async promptFromTemplate(name, args = []) {
+        const resources = await this.resolveResources();
+        const template = (resources.promptTemplates ?? []).find((candidate) => candidate.name === name);
+        if (!template)
+            throw new Error(`Unknown prompt template: ${name}`);
+        return await this.prompt(expandPromptTemplate(template, args));
+    }
+    steer(message) {
+        if (this.operation.idle)
+            throw new Error("Cannot steer while idle");
+        this.operation.steerQueue.push(message);
+        this.agent.steer(message);
+        void this.emitQueueUpdate();
+    }
+    followUp(message) {
+        if (this.operation.idle)
+            throw new Error("Cannot follow up while idle");
+        this.operation.followUpQueue.push(message);
+        this.agent.followUp(message);
+        void this.emitQueueUpdate();
+    }
+    nextTurn(message) {
+        this.conversation.nextTurnQueue.push(message);
+        void this.emitQueueUpdate();
+    }
+    async appendMessage(message) {
+        if (this.operation.idle) {
+            await this.session.appendMessage(message);
+            await this.syncFromTree();
+        }
+        else {
+            this.operation.pendingMutations.appendMessages.push(message);
+        }
+    }
+    async shell(command, options) {
+        return await this.env.exec(command, options);
+    }
+    async compact(customInstructions) {
+        if (!this.operation.idle)
+            throw new Error("compact() requires idle harness");
+        const model = this.conversation.model;
+        if (!model)
+            throw new Error("No model set for compaction");
+        const auth = await this.requestAuth?.(model);
+        if (!auth)
+            throw new Error("No auth available for compaction");
+        const branchEntries = await this.session.getBranch();
+        const preparation = prepareCompaction(branchEntries, DEFAULT_COMPACTION_SETTINGS);
+        if (!preparation)
+            throw new Error("Nothing to compact");
+        const hookResult = await this.emitHook("session_before_compact", {
+            type: "session_before_compact",
+            preparation,
+            branchEntries,
+            customInstructions,
+            signal: new AbortController().signal,
+        });
+        if (hookResult?.cancel)
+            throw new Error("Compaction cancelled");
+        const provided = hookResult?.compaction;
+        const result = provided ??
+            (await compact(preparation, model, auth.apiKey, auth.headers, customInstructions, undefined, this.conversation.thinkingLevel));
+        const entryId = await this.session.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, provided !== undefined);
+        const entry = await this.session.getEntry(entryId);
+        await this.syncFromTree();
+        if (entry?.type === "compaction") {
+            await this.emitOwn({ type: "session_compact", compactionEntry: entry, fromHook: provided !== undefined });
+        }
+        return result;
+    }
+    async navigateTree(targetId, options) {
+        if (!this.operation.idle)
+            throw new Error("navigateTree() requires idle harness");
+        const oldLeafId = await this.session.getLeafId();
+        if (oldLeafId === targetId)
+            return { cancelled: false };
+        const targetEntry = await this.session.getEntry(targetId);
+        if (!targetEntry)
+            throw new Error(`Entry ${targetId} not found`);
+        const { entries, commonAncestorId } = await collectEntriesForBranchSummary(this.session, oldLeafId, targetId);
+        const preparation = {
+            targetId,
+            oldLeafId,
+            commonAncestorId,
+            entriesToSummarize: entries,
+            userWantsSummary: options?.summarize ?? false,
+            customInstructions: options?.customInstructions,
+            replaceInstructions: options?.replaceInstructions,
+            label: options?.label,
+        };
+        const signal = new AbortController().signal;
+        const hookResult = await this.emitHook("session_before_tree", {
+            type: "session_before_tree",
+            preparation,
+            signal,
+        });
+        if (hookResult?.cancel)
+            return { cancelled: true };
+        let summaryEntry;
+        let summaryText = hookResult?.summary?.summary;
+        let summaryDetails = hookResult?.summary?.details;
+        if (!summaryText && options?.summarize && entries.length > 0) {
+            const model = this.conversation.model;
+            if (!model)
+                throw new Error("No model set for branch summary");
+            const auth = await this.requestAuth?.(model);
+            if (!auth)
+                throw new Error("No auth available for branch summary");
+            const branchSummary = await generateBranchSummary(entries, {
+                model,
+                apiKey: auth.apiKey,
+                headers: auth.headers,
+                signal: new AbortController().signal,
+                customInstructions: hookResult?.customInstructions ?? options?.customInstructions,
+                replaceInstructions: hookResult?.replaceInstructions ?? options?.replaceInstructions,
+            });
+            if (branchSummary.aborted)
+                return { cancelled: true };
+            if (branchSummary.error)
+                throw new Error(branchSummary.error);
+            summaryText = branchSummary.summary;
+            summaryDetails = {
+                readFiles: branchSummary.readFiles ?? [],
+                modifiedFiles: branchSummary.modifiedFiles ?? [],
+            };
+        }
+        let editorText;
+        let newLeafId;
+        if (targetEntry.type === "message" && targetEntry.message.role === "user") {
+            newLeafId = targetEntry.parentId;
+            const content = targetEntry.message.content;
+            editorText =
+                typeof content === "string"
+                    ? content
+                    : content
+                        .filter((c) => c.type === "text")
+                        .map((c) => c.text)
+                        .join("");
+        }
+        else if (targetEntry.type === "custom_message") {
+            newLeafId = targetEntry.parentId;
+            editorText =
+                typeof targetEntry.content === "string"
+                    ? targetEntry.content
+                    : targetEntry.content
+                        .filter((c) => c.type === "text")
+                        .map((c) => c.text)
+                        .join("");
+        }
+        else {
+            newLeafId = targetId;
+        }
+        const summaryId = await this.session.moveTo(newLeafId, summaryText
+            ? {
+                summary: summaryText,
+                details: summaryDetails,
+                fromHook: hookResult?.summary !== undefined,
+            }
+            : undefined);
+        if (summaryId) {
+            summaryEntry = await this.session.getEntry(summaryId);
+        }
+        await this.syncFromTree();
+        await this.emitOwn({
+            type: "session_tree",
+            newLeafId: await this.session.getLeafId(),
+            oldLeafId,
+            summaryEntry,
+            fromHook: hookResult?.summary !== undefined,
+        });
+        return { cancelled: false, editorText, summaryEntry };
+    }
+    async setModel(model) {
+        if (this.operation.idle) {
+            const previousModel = this.conversation.model;
+            this.conversation.model = model;
+            this.agent.state.model = model;
+            await this.session.appendModelChange(model.provider, model.id);
+            await this.emitOwn({ type: "model_select", model, previousModel, source: "set" });
+        }
+        else {
+            this.operation.pendingMutations.model = model;
+        }
+    }
+    async setThinkingLevel(level) {
+        if (this.operation.idle) {
+            const previousLevel = this.conversation.thinkingLevel;
+            this.conversation.thinkingLevel = level;
+            this.agent.state.thinkingLevel = level;
+            await this.session.appendThinkingLevelChange(level);
+            await this.emitOwn({ type: "thinking_level_select", level, previousLevel });
+        }
+        else {
+            this.operation.pendingMutations.thinkingLevel = level;
+        }
+    }
+    async setActiveTools(toolNames) {
+        if (this.operation.idle) {
+            this.conversation.activeToolNames = [...toolNames];
+            this.agent.state.tools = this.getActiveTools();
+        }
+        else {
+            this.operation.pendingMutations.activeToolNames = [...toolNames];
+        }
+    }
+    async abort() {
+        this.operation.abortRequested = true;
+        const clearedSteer = [...this.operation.steerQueue];
+        const clearedFollowUp = [...this.operation.followUpQueue];
+        this.operation.steerQueue = [];
+        this.operation.followUpQueue = [];
+        this.agent.clearAllQueues();
+        await this.emitQueueUpdate();
+        this.agent.abort();
+        await this.agent.waitForIdle();
+        await this.emitOwn({ type: "abort", clearedSteer, clearedFollowUp });
+        return { clearedSteer, clearedFollowUp };
+    }
+    async waitForIdle() {
+        await this.agent.waitForIdle();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    on(type, handler) {
+        let handlers = this.hooks.get(type);
+        if (!handlers) {
+            handlers = new Set();
+            this.hooks.set(type, handlers);
+        }
+        handlers.add(handler);
+        return () => handlers.delete(handler);
+    }
+}
+//# sourceMappingURL=agent-harness.js.map