@kkeve/suite 0.0.1 → 0.0.2

package/dist/agent/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentFactory = exports.AgentLoader = void 0;
-var loader_1 = require("./loader");
-Object.defineProperty(exports, "AgentLoader", { enumerable: true, get: function () { return loader_1.AgentLoader; } });
-var factory_1 = require("./factory");
-Object.defineProperty(exports, "AgentFactory", { enumerable: true, get: function () { return factory_1.AgentFactory; } });

package/dist/agent/loader.d.ts

@@ -1,22 +0,0 @@
-/**
- * AgentLoader — discovers and loads .md agent definitions from a directory
- *
- * Mirrors SkillLoader pattern (instance-based, no singleton).
- * Each .md file uses YAML frontmatter (same as SKILL.md) to define agent metadata.
- */
-import type { AgentRegistryDefinition } from './types';
-export declare class AgentLoader {
-    private agentsDir;
-    private agents;
-    constructor(agentsDir: string);
-    discover(): Promise<void>;
-    get(name: string): AgentRegistryDefinition | undefined;
-    has(name: string): boolean;
-    getAll(): Map<string, AgentRegistryDefinition>;
-    listAvailable(): Array<{
-        name: string;
-        description: string;
-        outputType?: string;
-    }>;
-    reset(): void;
-}

package/dist/agent/loader.js

@@ -1,117 +0,0 @@
-"use strict";
-/**
- * AgentLoader — discovers and loads .md agent definitions from a directory
- *
- * Mirrors SkillLoader pattern (instance-based, no singleton).
- * Each .md file uses YAML frontmatter (same as SKILL.md) to define agent metadata.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentLoader = void 0;
-const fs = __importStar(require("node:fs/promises"));
-const path = __importStar(require("node:path"));
-const glob_1 = require("glob");
-const frontmatter_parser_1 = require("../skill/frontmatter-parser");
-class AgentLoader {
-    agentsDir;
-    agents = new Map();
-    constructor(agentsDir) {
-        this.agentsDir = agentsDir;
-    }
-    async discover() {
-        const absoluteDir = path.resolve(this.agentsDir);
-        try {
-            const stats = await fs.stat(absoluteDir).catch(() => null);
-            if (!stats || !stats.isDirectory()) {
-                console.warn(`[AgentLoader] Agents directory not found: ${absoluteDir}`);
-                return;
-            }
-            const agentFiles = await (0, glob_1.glob)('*.md', {
-                cwd: absoluteDir,
-                absolute: true,
-                nodir: true,
-            });
-            for (const agentFile of agentFiles) {
-                try {
-                    const content = await fs.readFile(agentFile, 'utf-8');
-                    const parsed = (0, frontmatter_parser_1.parseSkillFrontmatter)(content);
-                    if (!parsed || !parsed.name) {
-                        console.warn(`[AgentLoader] Invalid agent file: ${agentFile}`);
-                        continue;
-                    }
-                    const tools = parsed.allowedTools ?? [];
-                    const agent = {
-                        name: parsed.name,
-                        description: parsed.description,
-                        tools,
-                        outputType: parsed.outputType,
-                        model: undefined,
-                        prompt: parsed.body,
-                        location: agentFile,
-                    };
-                    this.agents.set(parsed.name, agent);
-                    console.log(`[AgentLoader] Loaded agent: "${parsed.name}" (tools: ${tools.join(', ')}, outputType: ${parsed.outputType ?? 'N/A'})`);
-                }
-                catch (err) {
-                    console.warn(`[AgentLoader] Failed to load ${agentFile}: ${err.message}`);
-                }
-            }
-            console.log(`[AgentLoader] Total agents: ${this.agents.size}`);
-        }
-        catch (err) {
-            console.warn(`[AgentLoader] Error discovering agents: ${err.message}`);
-        }
-    }
-    get(name) {
-        return this.agents.get(name);
-    }
-    has(name) {
-        return this.agents.has(name);
-    }
-    getAll() {
-        return this.agents;
-    }
-    listAvailable() {
-        return Array.from(this.agents.values()).map(a => ({
-            name: a.name,
-            description: a.description,
-            outputType: a.outputType,
-        }));
-    }
-    reset() {
-        this.agents.clear();
-    }
-}
-exports.AgentLoader = AgentLoader;

package/dist/agent/types.d.ts

@@ -1,9 +0,0 @@
-export interface AgentRegistryDefinition {
-    name: string;
-    description: string;
-    tools: string[];
-    outputType?: string;
-    model?: string;
-    prompt: string;
-    location: string;
-}

package/dist/agent/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent-loop/complete-task.d.ts

@@ -1,28 +0,0 @@
-/**
- * Complete Task Tool — signals that the agent has finished its task.
- *
- * Reference: gemini-cli CompleteTaskTool (tools/complete-task.ts)
- *
- * This tool is automatically registered in every agent loop execution.
- * When the LLM calls this tool, the agent loop terminates with GOAL mode.
- *
- * The `result` parameter can be either:
- * - A structured JSON object (when the agent has a defined output schema)
- * - A plain string summary (for conversational tasks)
- */
-import { z } from 'zod/v4';
-import type { ToolDefinition } from './types';
-export interface CompleteTaskToolOptions {
-    outputHint?: string;
-}
-export declare const CompleteTaskSchema: z.ZodObject<{
-    result: z.ZodAny;
-    _result: z.ZodOptional<z.ZodEnum<{
-        PASSED: "PASSED";
-        FAILED: "FAILED";
-        BLOCKED: "BLOCKED";
-    }>>;
-    _summary: z.ZodOptional<z.ZodString>;
-    _blockedReason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare function createCompleteTaskTool(options?: CompleteTaskToolOptions): ToolDefinition;

package/dist/agent-loop/complete-task.js

@@ -1,70 +0,0 @@
-"use strict";
-/**
- * Complete Task Tool — signals that the agent has finished its task.
- *
- * Reference: gemini-cli CompleteTaskTool (tools/complete-task.ts)
- *
- * This tool is automatically registered in every agent loop execution.
- * When the LLM calls this tool, the agent loop terminates with GOAL mode.
- *
- * The `result` parameter can be either:
- * - A structured JSON object (when the agent has a defined output schema)
- * - A plain string summary (for conversational tasks)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompleteTaskSchema = void 0;
-exports.createCompleteTaskTool = createCompleteTaskTool;
-const v4_1 = require("zod/v4");
-const types_1 = require("./types");
-exports.CompleteTaskSchema = v4_1.z.object({
-    result: v4_1.z.any().describe('Your final result. You can provide either a structured JSON object or a text summary. ' +
-        'This is the ONLY way to finish the task — call this tool when you are done.'),
-    _result: v4_1.z.enum(['PASSED', 'FAILED', 'BLOCKED']).optional().describe('Execution result. "PASSED" = task completed successfully. ' +
-        '"FAILED" = task failed (e.g. tests did not pass). ' +
-        '"BLOCKED" = unresolved items prevent downstream steps from proceeding safely. ' +
-        'Use "BLOCKED" when critical information is missing and proceeding would produce unreliable results.'),
-    _summary: v4_1.z.string().optional().describe('Brief human-readable summary of the result (1-2 sentences). Used by the orchestrator to display progress. ' +
-        'If omitted, the orchestrator will derive a summary from the result object.'),
-    _blockedReason: v4_1.z.string().optional().describe('Reason for blocking. Required when _result is "BLOCKED". ' +
-        'Describe what information is missing and what needs to be confirmed before proceeding.'),
-});
-function createCompleteTaskTool(options) {
-    const hint = options?.outputHint;
-    const baseDescription = 'Call this tool to submit your final result and complete the task. ' +
-        'This is the ONLY way to finish. You MUST call this tool when you ' +
-        'have completed your work.';
-    const description = hint
-        ? baseDescription + '\n\n' + hint
-        : baseDescription;
-    const structuredDesc = hint
-        ? 'Structured JSON result. ' + hint
-        : 'Structured JSON result with key fields matching the expected output schema.';
-    return {
-        name: types_1.COMPLETE_TASK_TOOL_NAME,
-        description,
-        inputSchema: exports.CompleteTaskSchema,
-        execute: async (args) => {
-            const result = typeof args.result === 'string' ? args.result : args.result;
-            return { result, taskCompleted: true };
-        },
-        customJsonSchema: {
-            type: 'object',
-            properties: {
-                result: {
-                    oneOf: [
-                        {
-                            type: 'object',
-                            description: structuredDesc,
-                        },
-                        {
-                            type: 'string',
-                            description: 'Plain text summary of what you accomplished.',
-                        },
-                    ],
-                    description: 'Your final result. Provide structured JSON when a schema is defined, or a text summary otherwise.',
-                },
-            },
-            required: ['result'],
-        },
-    };
-}

package/dist/agent-loop/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * Agent Loop module — universal agent execution engine
- *
- * Provides the core agent loop runtime that executes an AgentDefinition
- * by calling the LLM in a while loop, processing tool_calls, and
- * terminating when complete_task is called or limits are reached.
- *
- * Reference: gemini-cli LocalAgentExecutor (agents/local-executor.ts)
- */
-export { AgentLoop } from './loop';
-export { createCompleteTaskTool, CompleteTaskSchema } from './complete-task';
-export type { CompleteTaskToolOptions } from './complete-task';
-export type { AgentDefinition, AgentEvent, AgentEventCallback, AgentLoopContext, AgentResult, AgentTerminateMode, ToolDefinition, ToolExecutionContext, } from './types';
-export { ToolRegistry, COMPLETE_TASK_TOOL_NAME, DEFAULT_MAX_TURNS, DEFAULT_MAX_TIME_MINUTES, } from './types';
-export { detectRuntimeEnvironment } from './runtime';
-export type { RuntimeEnvironment } from './runtime';

package/dist/agent-loop/index.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * Agent Loop module — universal agent execution engine
- *
- * Provides the core agent loop runtime that executes an AgentDefinition
- * by calling the LLM in a while loop, processing tool_calls, and
- * terminating when complete_task is called or limits are reached.
- *
- * Reference: gemini-cli LocalAgentExecutor (agents/local-executor.ts)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectRuntimeEnvironment = exports.DEFAULT_MAX_TIME_MINUTES = exports.DEFAULT_MAX_TURNS = exports.COMPLETE_TASK_TOOL_NAME = exports.ToolRegistry = exports.CompleteTaskSchema = exports.createCompleteTaskTool = exports.AgentLoop = void 0;
-var loop_1 = require("./loop");
-Object.defineProperty(exports, "AgentLoop", { enumerable: true, get: function () { return loop_1.AgentLoop; } });
-var complete_task_1 = require("./complete-task");
-Object.defineProperty(exports, "createCompleteTaskTool", { enumerable: true, get: function () { return complete_task_1.createCompleteTaskTool; } });
-Object.defineProperty(exports, "CompleteTaskSchema", { enumerable: true, get: function () { return complete_task_1.CompleteTaskSchema; } });
-var types_1 = require("./types");
-Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return types_1.ToolRegistry; } });
-// Constants
-Object.defineProperty(exports, "COMPLETE_TASK_TOOL_NAME", { enumerable: true, get: function () { return types_1.COMPLETE_TASK_TOOL_NAME; } });
-Object.defineProperty(exports, "DEFAULT_MAX_TURNS", { enumerable: true, get: function () { return types_1.DEFAULT_MAX_TURNS; } });
-Object.defineProperty(exports, "DEFAULT_MAX_TIME_MINUTES", { enumerable: true, get: function () { return types_1.DEFAULT_MAX_TIME_MINUTES; } });
-// Runtime Environment
-var runtime_1 = require("./runtime");
-Object.defineProperty(exports, "detectRuntimeEnvironment", { enumerable: true, get: function () { return runtime_1.detectRuntimeEnvironment; } });

package/dist/agent-loop/loop.d.ts

@@ -1,42 +0,0 @@
-/**
- * Agent Loop — universal agent execution engine
- *
- * Reference: gemini-cli LocalAgentExecutor (agents/local-executor.ts L120-1518)
- * Key adaptation: uses OpenAIClient.chat() instead of GeminiChat,
- * decoupled tool execution via ToolRegistry, simplified timeout.
- *
- * Core loop:
- * 1. Build messages (system prompt + user query)
- * 2. While (!done):
- *    a. Check termination (max turns, timeout, abort)
- *    b. Call LLM via chatWithTools → get assistant message
- *    c. If no tool_calls → ERROR_NO_COMPLETE_TASK (or handle text-only response)
- *    d. For each tool_call:
- *       - If complete_task → done, extract result
- *       - Otherwise → execute via ToolRegistry → append tool response
- *    e. Emit events (thought_chunk, tool_call_start/end)
- * 3. Return AgentResult with termination mode and output
- */
-import type { AgentDefinition, AgentEventCallback, AgentResult } from './types';
-import { ToolRegistry } from './types';
-import type { LLM } from '../llm/index';
-export declare class AgentLoop {
-    private llm;
-    private toolRegistry;
-    constructor(llm: LLM, toolRegistry: ToolRegistry);
-    /**
-     * Execute an agent definition with the given event callback and optional abort signal.
-     *
-     * Reference: gemini-cli LocalAgentExecutor.run() (L537-566) and runInternal() (L568-730)
-     */
-    execute(definition: AgentDefinition, onEvent?: AgentEventCallback, signal?: AbortSignal): Promise<AgentResult>;
-    /**
-     * Check if the agent should terminate.
-     * Returns a terminate reason if termination is needed, null otherwise.
-     */
-    private checkTermination;
-    /**
-     * Emit an event to the callback, if provided.
-     */
-    private emitEvent;
-}

package/dist/agent-loop/loop.js

@@ -1,282 +0,0 @@
-"use strict";
-/**
- * Agent Loop — universal agent execution engine
- *
- * Reference: gemini-cli LocalAgentExecutor (agents/local-executor.ts L120-1518)
- * Key adaptation: uses OpenAIClient.chat() instead of GeminiChat,
- * decoupled tool execution via ToolRegistry, simplified timeout.
- *
- * Core loop:
- * 1. Build messages (system prompt + user query)
- * 2. While (!done):
- *    a. Check termination (max turns, timeout, abort)
- *    b. Call LLM via chatWithTools → get assistant message
- *    c. If no tool_calls → ERROR_NO_COMPLETE_TASK (or handle text-only response)
- *    d. For each tool_call:
- *       - If complete_task → done, extract result
- *       - Otherwise → execute via ToolRegistry → append tool response
- *    e. Emit events (thought_chunk, tool_call_start/end)
- * 3. Return AgentResult with termination mode and output
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentLoop = void 0;
-const types_1 = require("./types");
-const complete_task_1 = require("./complete-task");
-const index_1 = require("../llm/index");
-/**
- * Universal agent execution engine.
- *
- * Usage:
- * ```typescript
- * const loop = new AgentLoop(llm, toolRegistry)
- * const result = await loop.execute(
- *   { name: 'my-agent', systemPrompt: '...', query: 'Do X' },
- *   (event) => { }
- */
-const FILE_CONTENT_TRUNCATE = 80;
-function truncateFileContent(data, toolName) {
-    if (!toolName)
-        return data;
-    const result = { ...data };
-    // 截断顶层 content（read_files 返回结果等）
-    if ((toolName === 'write_file' || toolName === 'edit_file') && typeof data.content === 'string' && data.content.length > FILE_CONTENT_TRUNCATE) {
-        result.content = data.content.slice(0, FILE_CONTENT_TRUNCATE) + `... (${data.content.length} chars)`;
-    }
-    // 截断 args.content（tool_call_start 中 write_file/edit_file 的参数）
-    if ((toolName === 'write_file' || toolName === 'edit_file') && data.args && typeof data.args.content === 'string' && data.args.content.length > FILE_CONTENT_TRUNCATE) {
-        result.args = { ...data.args };
-        result.args.content = data.args.content.slice(0, FILE_CONTENT_TRUNCATE) + `... (${data.args.content.length} chars)`;
-    }
-    if (toolName === 'read_files' && typeof data.result === 'string' && data.result.length > FILE_CONTENT_TRUNCATE) {
-        result.result = data.result.slice(0, FILE_CONTENT_TRUNCATE) + `... (${data.result.length} chars)`;
-    }
-    return result;
-}
-class AgentLoop {
-    llm;
-    toolRegistry;
-    constructor(llm, toolRegistry) {
-        this.llm = llm;
-        this.toolRegistry = toolRegistry;
-    }
-    /**
-     * Execute an agent definition with the given event callback and optional abort signal.
-     *
-     * Reference: gemini-cli LocalAgentExecutor.run() (L537-566) and runInternal() (L568-730)
-     */
-    async execute(definition, onEvent, signal) {
-        const startTime = Date.now();
-        const maxTurns = definition.maxTurns ?? types_1.DEFAULT_MAX_TURNS;
-        const maxTimeMs = (definition.maxTimeMinutes ?? types_1.DEFAULT_MAX_TIME_MINUTES) * 60 * 1000;
-        let turnCounter = 0;
-        let terminateReason = types_1.TM_ERROR;
-        let finalResult = null;
-        // 1. Build initial messages
-        const messages = [];
-        if (definition.systemPrompt) {
-            messages.push({ role: 'system', content: definition.systemPrompt });
-        }
-        const query = definition.query ?? 'Get Started!';
-        messages.push({ role: 'user', content: query });
-        // 2. Use a local tool registry copy to avoid mutating the shared one
-        const localRegistry = new types_1.ToolRegistry();
-        // Copy all tools from the shared registry
-        for (const name of this.toolRegistry.getAllToolNames()) {
-            const tool = this.toolRegistry.get(name);
-            if (tool)
-                localRegistry.register(tool);
-        }
-        // Ensure complete_task is registered (check if caller already registered one)
-        if (!localRegistry.has(types_1.COMPLETE_TASK_TOOL_NAME)) {
-            localRegistry.register((0, complete_task_1.createCompleteTaskTool)());
-        }
-        // Determine which tools are available for this agent
-        const toolsMap = definition.toolNames
-            ? localRegistry.getToolsMapSubset([...definition.toolNames, types_1.COMPLETE_TASK_TOOL_NAME])
-            : localRegistry.getToolsMap();
-        // 3. Emit start event
-        this.emitEvent(onEvent, 'agent_start', definition.name, {
-            agentName: definition.name,
-            maxTurns,
-            maxTimeMinutes: maxTimeMs / 60000,
-            toolNames: Object.keys(toolsMap),
-        });
-        // 4. Main loop (reference: gemini-cli runInternal L667-726)
-        try {
-            while (true) {
-                // 4a. Check termination conditions
-                const terminationCheck = this.checkTermination(turnCounter, maxTurns, startTime, maxTimeMs, signal);
-                if (terminationCheck) {
-                    terminateReason = terminationCheck;
-                    break;
-                }
-                // 4b. Call LLM
-                this.emitEvent(onEvent, 'thought_chunk', definition.name, {
-                    turn: turnCounter,
-                    message: `Turn ${turnCounter + 1}/${maxTurns}: Calling model...`,
-                });
-                const chatResult = await this.llm.chatWithTools(messages, toolsMap, signal);
-                // 4c. Process assistant response
-                const assistantMessage = chatResult.message;
-                messages.push(assistantMessage);
-                // 4d. Handle text-only response (no tool_calls)
-                if (!assistantMessage.tool_calls?.length) {
-                    // The LLM responded with text instead of calling any tool.
-                    // This means it didn't call complete_task → ERROR_NO_COMPLETE_TASK.
-                    // But if there's meaningful text content, we can treat it as the final result.
-                    const textContent = typeof assistantMessage.content === 'string'
-                        ? assistantMessage.content
-                        : null;
-                    if (textContent) {
-                        // The LLM gave a text answer but didn't follow the protocol.
-                        // Treat it as a soft completion.
-                        this.emitEvent(onEvent, 'thought_chunk', definition.name, {
-                            message: 'Model returned text content without calling complete_task. Treating as final answer.',
-                        });
-                        finalResult = textContent;
-                        terminateReason = types_1.TM_GOAL;
-                    }
-                    else {
-                        terminateReason = types_1.TM_ERROR_NO_COMPLETE_TASK;
-                    }
-                    break;
-                }
-                // 4e. Process each tool_call
-                let taskCompleted = false;
-                for (const toolCall of assistantMessage.tool_calls) {
-                    const toolName = toolCall.function.name;
-                    let toolArgs;
-                    try {
-                        toolArgs = JSON.parse(toolCall.function.arguments);
-                    }
-                    catch {
-                        // Handle malformed JSON (common with LLM outputs)
-                        toolArgs = {};
-                    }
-                    // Check if this is the termination signal
-                    if (toolName === types_1.COMPLETE_TASK_TOOL_NAME) {
-                        finalResult = JSON.stringify(toolArgs);
-                        taskCompleted = true;
-                        // Append tool response to messages (for history completeness)
-                        messages.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            name: types_1.COMPLETE_TASK_TOOL_NAME,
-                            content: JSON.stringify({ result: finalResult, taskCompleted: true }),
-                        });
-                        break;
-                    }
-                    // Execute the tool via registry
-                    this.emitEvent(onEvent, 'tool_call_start', definition.name, {
-                        tool: toolName,
-                        args: toolArgs,
-                        turn: turnCounter,
-                    }, toolName);
-                    let toolResult;
-                    try {
-                        const toolContext = {
-                            runtime: globalThis.__runtime ?? {},
-                            cwd: definition.cwd ?? process.cwd(),
-                            readOnlyPaths: definition.readOnlyPaths,
-                        };
-                        toolResult = await localRegistry.execute(toolName, toolArgs, toolContext);
-                    }
-                    catch (error) {
-                        toolResult = { error: error.message || String(error), isError: true };
-                        this.emitEvent(onEvent, 'agent_error', definition.name, {
-                            tool: toolName,
-                            error: error.message,
-                        });
-                    }
-                    this.emitEvent(onEvent, 'tool_call_end', definition.name, {
-                        tool: toolName,
-                        result: typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult),
-                        turn: turnCounter,
-                    }, toolName);
-                    // Append tool response to messages
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolName,
-                        content: typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult),
-                    });
-                }
-                if (taskCompleted) {
-                    terminateReason = types_1.TM_GOAL;
-                    break;
-                }
-                turnCounter++;
-            }
-        }
-        catch (error) {
-            // Check if it's an abort error
-            if (error?.name === 'AbortError' || signal?.aborted) {
-                terminateReason = types_1.TM_ABORTED;
-            }
-            else {
-                terminateReason = types_1.TM_ERROR;
-                finalResult = null;
-                // Enhanced error logging for debugging
-                const errorDetail = error instanceof index_1.InvokeError
-                    ? `[InvokeError type=${error.type} retryable=${error.retryable}] ${error.message}`
-                    : error?.message || String(error);
-                console.error(`[AgentLoop] Agent "${definition.name}" terminated with ERROR: ${errorDetail}`);
-                if (error instanceof index_1.InvokeError && error.rawResponse) {
-                    console.error(`[AgentLoop] InvokeError rawResponse:`, JSON.stringify(error.rawResponse).slice(0, 500));
-                }
-                this.emitEvent(onEvent, 'agent_error', definition.name, {
-                    error: errorDetail,
-                    errorType: error?.type || error?.constructor?.name || 'unknown',
-                    phase: 'execution',
-                    turn: turnCounter,
-                });
-            }
-        }
-        // 5. Emit end event
-        this.emitEvent(onEvent, 'agent_end', definition.name, {
-            terminateReason,
-            turnCount: turnCounter,
-            durationMs: Date.now() - startTime,
-            output: finalResult ?? undefined,
-        });
-        // 6. Return result
-        return {
-            success: terminateReason === types_1.TM_GOAL,
-            output: finalResult ?? undefined,
-            terminateReason,
-            turnCount: turnCounter,
-            durationMs: Date.now() - startTime,
-            error: terminateReason !== types_1.TM_GOAL
-                ? `Agent terminated: ${terminateReason}${terminateReason === types_1.TM_ERROR_NO_COMPLETE_TASK ? ' (model stopped calling tools without complete_task)' : ''}`
-                : undefined,
-        };
-    }
-    /**
-     * Check if the agent should terminate.
-     * Returns a terminate reason if termination is needed, null otherwise.
-     */
-    checkTermination(turnCounter, maxTurns, startTime, maxTimeMs, signal) {
-        if (turnCounter >= maxTurns) {
-            return types_1.TM_MAX_TURNS;
-        }
-        if (signal?.aborted) {
-            return types_1.TM_ABORTED;
-        }
-        if (Date.now() - startTime >= maxTimeMs) {
-            return types_1.TM_TIMEOUT;
-        }
-        return null;
-    }
-    /**
-     * Emit an event to the callback, if provided.
-     */
-    emitEvent(onEvent, type, streamId, data, toolName) {
-        if (onEvent) {
-            const processed = (type === 'tool_call_start' || type === 'tool_call_end')
-                ? truncateFileContent(data, toolName)
-                : data;
-            onEvent({ type, streamId, data: processed });
-        }
-    }
-}
-exports.AgentLoop = AgentLoop;

package/dist/agent-loop/runtime.d.ts

@@ -1,40 +0,0 @@
-/**
- * RuntimeEnvironment — runtime environment detection
- *
- * Detects available system binaries (git/codegraph/playwright/node),
- * and provides config paths (env).
- *
- * Tools (core/tools/*) get paths via ToolExecutionContext.runtime,
- * instead of resolving binaries themselves.
- *
- * Design decisions:
- * D02: Layer 1: RuntimeEnvironment provides binary paths
- *      Layer 2: Tool execute() gets paths from runtime
- *      Layer 3: Skill only ctx.tools.call(), no path awareness
- * D04: Business-specific paths (keveWikiDir/reposBaseDir) removed from core.
- *      Agent package can add them in its own runtime extension.
- */
-export interface RuntimeEnvironment {
-    /** Git binary path */
-    gitBin: string;
-    /** Codegraph binary path */
-    codegraphBin: string;
-    /** Playwright binary path (usually in agent's node_modules/.bin) */
-    playwrightBin: string;
-    /** Node binary path */
-    nodeBin: string;
-    /** Package manager (pnpm/npm/yarn) */
-    packageManager: string;
-    /** Environment variables (tokens, configs) */
-    env: Record<string, string>;
-}
-/**
- * Detect the runtime environment.
- *
- * Scans for binaries, loads env vars.
- * Called once at startup (entry.ts) and passed to Pipeline → SkillContext.
- *
- * @param cwd - Starting directory (defaults to process.cwd())
- * @param agentDir - Agent package directory for finding node_modules binaries
- */
-export declare function detectRuntimeEnvironment(cwd?: string, agentDir?: string): RuntimeEnvironment;