openplanter 0.1.0

package/dist/engine.js

@@ -0,0 +1,1036 @@
+/**
+ * Core RLMEngine – orchestrates the recursive agent loop.
+ *
+ * Migrated from agent/engine.py to TypeScript (ESM, ES2022, Node16).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ModelError } from "./model.js";
+import { buildSystemPrompt } from "./prompts.js";
+import { get_tool_definitions } from "./tool-defs.js";
+import { WorkspaceTools } from "./tools.js";
+function asRecord(obj) {
+    return obj;
+}
+// ---------------------------------------------------------------------------
+// Helper functions
+// ---------------------------------------------------------------------------
+/** One-line summary of tool call arguments. */
+export function summarizeArgs(args, maxLen = 120) {
+    const parts = [];
+    for (const [k, v] of Object.entries(args)) {
+        let s = String(v);
+        if (s.length > 60) {
+            s = s.slice(0, 57) + "...";
+        }
+        parts.push(`${k}=${s}`);
+    }
+    let joined = parts.join(", ");
+    if (joined.length > maxLen) {
+        joined = joined.slice(0, maxLen - 3) + "...";
+    }
+    return joined;
+}
+/** First line or truncated preview of an observation. */
+export function summarizeObservation(text, maxLen = 200) {
+    let first = text.split("\n", 1)[0].trim();
+    if (first.length > maxLen) {
+        first = first.slice(0, maxLen - 3) + "...";
+    }
+    const lines = (text.match(/\n/g) ?? []).length + 1;
+    const chars = text.length;
+    if (lines > 1) {
+        return `${first} (${lines} lines, ${chars} chars)`;
+    }
+    return first;
+}
+// ---------------------------------------------------------------------------
+// Legacy alias
+// ---------------------------------------------------------------------------
+/** Legacy alias for tests and external code that reference SYSTEM_PROMPT directly. */
+export const SYSTEM_PROMPT = buildSystemPrompt(true);
+// ---------------------------------------------------------------------------
+// Context window constants
+// ---------------------------------------------------------------------------
+export const _MODEL_CONTEXT_WINDOWS = {
+    "claude-opus-4-6": 200_000,
+    "claude-sonnet-4-5-20250929": 200_000,
+    "claude-haiku-4-5-20251001": 200_000,
+    "gpt-4o": 128_000,
+    "gpt-4.1": 1_000_000,
+    "gpt-5-turbo-16k": 16_000,
+};
+export const _DEFAULT_CONTEXT_WINDOW = 128_000;
+const _CONDENSATION_THRESHOLD = 0.75;
+// ---------------------------------------------------------------------------
+// Model tier helpers
+// ---------------------------------------------------------------------------
+/**
+ * Determine capability tier for a model. Lower number = higher capability.
+ *
+ * Anthropic chain (by model name):
+ *   opus → 1, sonnet → 2, haiku → 3
+ * OpenAI codex chain (by reasoning effort):
+ *   xhigh → 1, high → 2, medium → 3, low → 4
+ * Unknown → 2
+ */
+export function modelTier(modelName, reasoningEffort = null) {
+    const lower = modelName.toLowerCase();
+    if (lower.includes("opus"))
+        return 1;
+    if (lower.includes("sonnet"))
+        return 2;
+    if (lower.includes("haiku"))
+        return 3;
+    if (lower.startsWith("gpt-5") && lower.includes("codex")) {
+        const effort = (reasoningEffort ?? "").toLowerCase();
+        const map = {
+            xhigh: 1,
+            high: 2,
+            medium: 3,
+            low: 4,
+        };
+        return map[effort] ?? 2;
+    }
+    return 2;
+}
+/**
+ * Return [modelName, reasoningEffort] for the lowest-tier executor.
+ *
+ * Anthropic models → haiku. Unknown → no downgrade (return same name).
+ */
+export function lowestTierModel(modelName) {
+    const lower = modelName.toLowerCase();
+    if (lower.includes("claude")) {
+        return ["claude-haiku-4-5-20251001", null];
+    }
+    return [modelName, null];
+}
+// ---------------------------------------------------------------------------
+// ExternalContext
+// ---------------------------------------------------------------------------
+export class ExternalContext {
+    observations = [];
+    add(text) {
+        this.observations.push(text);
+    }
+    summary(maxItems = 12, maxChars = 8000) {
+        if (this.observations.length === 0)
+            return "(empty)";
+        if (maxItems <= 0)
+            return "(empty)";
+        const recent = this.observations.slice(-maxItems);
+        const joined = recent.join("\n\n");
+        if (joined.length <= maxChars)
+            return joined;
+        return `${joined.slice(0, maxChars)}\n...[truncated external context]...`;
+    }
+}
+// ---------------------------------------------------------------------------
+// RLMEngine
+// ---------------------------------------------------------------------------
+export class RLMEngine {
+    model;
+    tools;
+    config;
+    systemPrompt;
+    sessionTokens;
+    modelFactory;
+    sessionDir;
+    sessionId;
+    _modelCache = new Map();
+    _shellCommandCounts = new Map();
+    constructor(opts) {
+        this.model = opts.model;
+        this.tools = opts.tools;
+        this.config = opts.config;
+        this.systemPrompt = opts.systemPrompt ?? "";
+        this.sessionTokens = opts.sessionTokens ?? {};
+        this.modelFactory = opts.modelFactory ?? null;
+        this.sessionDir = opts.sessionDir ?? null;
+        this.sessionId = opts.sessionId ?? null;
+        // __post_init__ equivalent
+        if (!this.systemPrompt) {
+            this.systemPrompt = buildSystemPrompt(this.config.recursive, this.config.acceptanceCriteria, this.config.demo);
+        }
+        const ac = this.config.acceptanceCriteria;
+        const toolDefs = get_tool_definitions({
+            includeSubtask: this.config.recursive,
+            includeAcceptanceCriteria: ac,
+        });
+        if ("toolDefs" in this.model) {
+            asRecord(this.model).toolDefs = toolDefs;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------
+    async solve(objective, onEvent) {
+        const [result] = await this.solveWithContext({ objective, onEvent });
+        return result;
+    }
+    async solveWithContext(opts) {
+        const { objective, context = null, onEvent = null, onStep = null, onContentDelta = null, replayLogger = null, } = opts;
+        if (!objective.trim()) {
+            return ["No objective provided.", context ?? new ExternalContext()];
+        }
+        this._shellCommandCounts.clear();
+        const activeContext = context ?? new ExternalContext();
+        const deadline = this.config.maxSolveSeconds > 0
+            ? performance.now() / 1000 + this.config.maxSolveSeconds
+            : 0;
+        try {
+            const result = await this._solveRecursive({
+                objective: objective.trim(),
+                depth: 0,
+                context: activeContext,
+                onEvent,
+                onStep,
+                onContentDelta,
+                deadline,
+                replayLogger,
+            });
+            return [result, activeContext];
+        }
+        finally {
+            const cleanup = asRecord(this.tools).cleanupBgJobs;
+            if (typeof cleanup === "function") {
+                cleanup.call(this.tools);
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Internal helpers
+    // -----------------------------------------------------------------------
+    _emit(msg, onEvent) {
+        if (onEvent) {
+            try {
+                onEvent(msg);
+            }
+            catch {
+                // swallow
+            }
+        }
+    }
+    _clipObservation(text) {
+        if (text.length <= this.config.maxObservationChars)
+            return text;
+        return (`${text.slice(0, this.config.maxObservationChars)}` +
+            `\n...[truncated ${text.length - this.config.maxObservationChars} chars]...`);
+    }
+    _runtimePolicyCheck(name, args, depth) {
+        if (name !== "run_shell")
+            return null;
+        const command = String(args.command ?? "").trim();
+        if (!command)
+            return null;
+        const key = `${depth}::${command}`;
+        const count = (this._shellCommandCounts.get(key) ?? 0) + 1;
+        this._shellCommandCounts.set(key, count);
+        if (count <= 2)
+            return null;
+        return ("Blocked by runtime policy: identical run_shell command repeated more than twice " +
+            "at the same depth. Change strategy instead of retrying the same command.");
+    }
+    async _judgeResult(objective, acceptanceCriteria, result, currentModel) {
+        if (!this.modelFactory)
+            return "PASS\n(no judge available)";
+        const cur = currentModel ?? this.model;
+        const curName = String(asRecord(cur).model ?? "");
+        const [judgeName, judgeEffort] = lowestTierModel(curName);
+        const cacheKey = `_judge_${judgeName}::${judgeEffort ?? ""}`;
+        if (!this._modelCache.has(cacheKey)) {
+            try {
+                this._modelCache.set(cacheKey, this.modelFactory(judgeName, judgeEffort));
+            }
+            catch {
+                return "PASS\n(no judge available)";
+            }
+        }
+        const judgeModel = this._modelCache.get(cacheKey);
+        if ("toolDefs" in judgeModel) {
+            asRecord(judgeModel).toolDefs = [];
+        }
+        const truncated = result.length > 4000 ? result.slice(0, 4000) : result;
+        const prompt = "You are a judge evaluating whether a task result meets acceptance criteria.\n\n" +
+            `Objective: ${objective}\n\n` +
+            `Acceptance criteria: ${acceptanceCriteria}\n\n` +
+            `Result:\n${truncated}\n\n` +
+            "Respond with exactly one line starting with PASS: or FAIL: followed by a brief explanation.";
+        try {
+            const conversation = judgeModel.createConversation("You are a concise evaluator.", prompt);
+            const turn = await judgeModel.complete(conversation);
+            const verdict = (turn.text ?? "").trim();
+            if (!verdict)
+                return "PASS\n(judge returned empty response)";
+            return verdict;
+        }
+        catch (exc) {
+            return `PASS\n(judge error: ${exc})`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Core recursive solver
+    // -----------------------------------------------------------------------
+    async _solveRecursive(opts) {
+        const { objective, depth, context, onEvent = null, onStep = null, onContentDelta = null, deadline = 0, modelOverride = null, replayLogger = null, } = opts;
+        const model = modelOverride ?? this.model;
+        this._emit(`[depth ${depth}] objective: ${objective}`, onEvent);
+        const nowIso = new Date().toISOString().replace(/\.\d+Z$/, "Z");
+        let initialMsgDict;
+        if (depth === 0 && !this.config.recursive) {
+            initialMsgDict = {
+                timestamp: nowIso,
+                objective,
+                max_steps_per_call: this.config.maxStepsPerCall,
+                workspace: this.config.workspace,
+                external_context_summary: context.summary(),
+            };
+        }
+        else {
+            const replHint = depth === 0
+                ? "Begin REPL cycle 1: start with a broad READ of the workspace."
+                : "Begin REPL cycle 1: parent has surveyed — READ only what this objective requires, then act.";
+            initialMsgDict = {
+                timestamp: nowIso,
+                objective,
+                depth,
+                max_depth: this.config.maxDepth,
+                max_steps_per_call: this.config.maxStepsPerCall,
+                workspace: this.config.workspace,
+                external_context_summary: context.summary(),
+                repl_hint: replHint,
+            };
+        }
+        if (this.sessionDir != null) {
+            initialMsgDict.session_dir = this.sessionDir;
+        }
+        if (this.sessionId != null) {
+            initialMsgDict.session_id = this.sessionId;
+        }
+        const initialMessage = JSON.stringify(initialMsgDict);
+        const conversation = model.createConversation(this.systemPrompt, initialMessage);
+        if (replayLogger && asRecord(replayLogger)._seq === 0) {
+            replayLogger.writeHeader({
+                provider: model.constructor.name,
+                model: String(asRecord(model).model ?? "(unknown)"),
+                baseUrl: String(asRecord(model).baseUrl ?? ""),
+                systemPrompt: this.systemPrompt,
+                toolDefs: asRecord(model).toolDefs ?? [],
+                reasoningEffort: asRecord(model).reasoningEffort ?? null,
+                temperature: asRecord(model).temperature ?? null,
+            });
+        }
+        for (let step = 1; step <= this.config.maxStepsPerCall; step++) {
+            if (deadline && performance.now() / 1000 > deadline) {
+                this._emit(`[d${depth}] wall-clock limit reached`, onEvent);
+                return "Time limit exceeded. Try a more focused objective.";
+            }
+            this._emit(`[d${depth}/s${step}] calling model...`, onEvent);
+            const t0 = performance.now() / 1000;
+            // Stream thinking/text deltas only for top-level calls
+            if (onContentDelta && depth === 0 && "onContentDelta" in model) {
+                asRecord(model).onContentDelta = onContentDelta;
+            }
+            let turn;
+            try {
+                turn = await model.complete(conversation);
+            }
+            catch (exc) {
+                if (exc instanceof ModelError) {
+                    this._emit(`[d${depth}/s${step}] model error: ${exc}`, onEvent);
+                    return `Model error at depth ${depth}, step ${step}: ${exc}`;
+                }
+                throw exc;
+            }
+            finally {
+                if ("onContentDelta" in model) {
+                    asRecord(model).onContentDelta = null;
+                }
+            }
+            const elapsed = performance.now() / 1000 - t0;
+            if (replayLogger) {
+                try {
+                    replayLogger.logCall({
+                        depth,
+                        step,
+                        messages: conversation.getMessages(),
+                        response: turn.raw_response,
+                        inputTokens: turn.input_tokens,
+                        outputTokens: turn.output_tokens,
+                        elapsedSec: elapsed,
+                    });
+                }
+                catch {
+                    // OSError equivalent – swallow
+                }
+            }
+            // Accumulate token usage per model
+            if (turn.input_tokens || turn.output_tokens) {
+                const modelName = String(asRecord(model).model ?? "(unknown)");
+                if (!this.sessionTokens[modelName]) {
+                    this.sessionTokens[modelName] = { input: 0, output: 0 };
+                }
+                this.sessionTokens[modelName].input += turn.input_tokens;
+                this.sessionTokens[modelName].output += turn.output_tokens;
+            }
+            model.appendAssistantTurn(conversation, turn);
+            // Context condensation
+            if (turn.input_tokens) {
+                const modelName = String(asRecord(model).model ?? "(unknown)");
+                const contextWindow = _MODEL_CONTEXT_WINDOWS[modelName] ?? _DEFAULT_CONTEXT_WINDOW;
+                if (turn.input_tokens > _CONDENSATION_THRESHOLD * contextWindow) {
+                    const condenseFn = asRecord(model).condenseConversation;
+                    if (typeof condenseFn === "function") {
+                        condenseFn.call(model, conversation);
+                    }
+                }
+            }
+            if (onStep) {
+                try {
+                    onStep({
+                        depth,
+                        step,
+                        objective,
+                        action: { name: "_model_turn" },
+                        observation: "",
+                        model_text: turn.text ?? "",
+                        tool_call_names: turn.tool_calls.map((tc) => tc.name),
+                        input_tokens: turn.input_tokens,
+                        output_tokens: turn.output_tokens,
+                        elapsed_sec: Math.round(elapsed * 100) / 100,
+                        is_final: false,
+                    });
+                }
+                catch {
+                    // swallow
+                }
+            }
+            // No tool calls + text present = final answer
+            if (turn.tool_calls.length === 0 && turn.text) {
+                const preview = turn.text.length > 200
+                    ? turn.text.slice(0, 200) + "..."
+                    : turn.text;
+                this._emit(`[d${depth}/s${step}] final answer (${turn.text.length} chars, ${elapsed.toFixed(1)}s): ${preview}`, onEvent);
+                if (onStep) {
+                    try {
+                        onStep({
+                            depth,
+                            step,
+                            objective,
+                            action: { name: "final", arguments: { text: turn.text } },
+                            observation: turn.text,
+                            is_final: true,
+                        });
+                    }
+                    catch {
+                        // swallow
+                    }
+                }
+                return turn.text;
+            }
+            // No tool calls and no text = unexpected empty response
+            if (turn.tool_calls.length === 0) {
+                this._emit(`[d${depth}/s${step}] empty model response (${elapsed.toFixed(1)}s), nudging...`, onEvent);
+                const emptyResult = {
+                    tool_call_id: "empty",
+                    name: "system",
+                    content: "No tool calls and no text in response. Please use a tool or provide a final answer.",
+                    is_error: false,
+                };
+                model.appendToolResults(conversation, [emptyResult]);
+                continue;
+            }
+            // Log tool calls from model
+            const tcNames = turn.tool_calls.map((tc) => tc.name);
+            this._emit(`[d${depth}/s${step}] model returned ${turn.tool_calls.length} tool call(s) (${elapsed.toFixed(1)}s): ${tcNames.join(", ")}`, onEvent);
+            if (turn.text) {
+                this._emit(`[d${depth}/s${step}] model text: ${turn.text.slice(0, 200)}`, onEvent);
+            }
+            // Execute all tool calls — parallel for subtask/execute, sequential for others.
+            const results = [];
+            let finalAnswer = null;
+            const PARALLEL_TOOLS = new Set(["subtask", "execute"]);
+            const sequential = [];
+            let parallel = [];
+            for (let i = 0; i < turn.tool_calls.length; i++) {
+                const tc = turn.tool_calls[i];
+                if (PARALLEL_TOOLS.has(tc.name)) {
+                    parallel.push([i, tc]);
+                }
+                else {
+                    sequential.push([i, tc]);
+                }
+            }
+            // If no factory and we have execute calls, fall back to sequential.
+            if (!this.modelFactory &&
+                parallel.some(([, tc]) => tc.name === "execute")) {
+                sequential.length = 0;
+                parallel = [];
+                for (let i = 0; i < turn.tool_calls.length; i++) {
+                    sequential.push([i, turn.tool_calls[i]]);
+                }
+            }
+            const indexedResults = new Map();
+            for (const [idx, tc] of sequential) {
+                const [resultEntry, isFinalEntry] = await this._runOneTool({
+                    tc,
+                    depth,
+                    step,
+                    objective,
+                    context,
+                    onEvent,
+                    onStep,
+                    deadline,
+                    currentModel: model,
+                    replayLogger,
+                });
+                indexedResults.set(idx, [resultEntry, isFinalEntry]);
+                if (isFinalEntry) {
+                    finalAnswer = resultEntry.content;
+                    break;
+                }
+            }
+            if (parallel.length > 0 && finalAnswer === null) {
+                const groupId = `d${depth}-s${step}-${Date.now()}`;
+                const beginGroup = asRecord(this.tools).beginParallelWriteGroup;
+                const endGroup = asRecord(this.tools).endParallelWriteGroup;
+                if (typeof beginGroup === "function") {
+                    beginGroup.call(this.tools, groupId);
+                }
+                try {
+                    const parallelPromises = parallel.map(async ([idx, tc]) => {
+                        const [resultEntry, isFinalEntry] = await this._runOneTool({
+                            tc,
+                            depth,
+                            step,
+                            objective,
+                            context,
+                            onEvent,
+                            onStep,
+                            deadline,
+                            currentModel: model,
+                            replayLogger,
+                            parallelGroupId: groupId,
+                            parallelOwner: `${tc.id ?? "tc"}:${idx}`,
+                        });
+                        indexedResults.set(idx, [resultEntry, isFinalEntry]);
+                    });
+                    await Promise.all(parallelPromises);
+                }
+                finally {
+                    if (typeof endGroup === "function") {
+                        endGroup.call(this.tools, groupId);
+                    }
+                }
+            }
+            const sortedIndices = Array.from(indexedResults.keys()).sort((a, b) => a - b);
+            for (const i of sortedIndices) {
+                const [r, isFinalEntry] = indexedResults.get(i);
+                results.push(r);
+                if (isFinalEntry && finalAnswer === null) {
+                    finalAnswer = r.content;
+                }
+            }
+            // Timestamp + step budget + context usage awareness
+            if (finalAnswer === null && results.length > 0) {
+                const budgetTotal = this.config.maxStepsPerCall;
+                const remaining = budgetTotal - step;
+                const tsTag = `[${new Date().toISOString().replace(/\.\d+Z$/, "Z")}]`;
+                const budgetTag = `[Step ${step}/${budgetTotal}]`;
+                const _mname = String(asRecord(model).model ?? "(unknown)");
+                const _ctxWindow = _MODEL_CONTEXT_WINDOWS[_mname] ?? _DEFAULT_CONTEXT_WINDOW;
+                const ctxTag = `[Context ${turn.input_tokens}/${_ctxWindow} tokens]`;
+                const r0 = results[0];
+                results[0] = {
+                    tool_call_id: r0.tool_call_id,
+                    name: r0.name,
+                    content: `${tsTag} ${budgetTag} ${ctxTag} ${r0.content}`,
+                    is_error: r0.is_error,
+                };
+                if (remaining > 0 && remaining <= Math.floor(budgetTotal / 4)) {
+                    const warning = `\n\n** BUDGET CRITICAL: ${remaining} of ${budgetTotal} steps remain. ` +
+                        "Stop exploring/surveying. Write your output files NOW with your best answer. " +
+                        "A partial result beats no result.";
+                    const rl = results[results.length - 1];
+                    results[results.length - 1] = {
+                        tool_call_id: rl.tool_call_id,
+                        name: rl.name,
+                        content: rl.content + warning,
+                        is_error: rl.is_error,
+                    };
+                }
+                else if (remaining <= Math.floor(budgetTotal / 2)) {
+                    const warning = `\n\n** BUDGET WARNING: ${remaining} of ${budgetTotal} steps remain. ` +
+                        "Focus on completing the task directly. Do not write exploration scripts.";
+                    const rl = results[results.length - 1];
+                    results[results.length - 1] = {
+                        tool_call_id: rl.tool_call_id,
+                        name: rl.name,
+                        content: rl.content + warning,
+                        is_error: rl.is_error,
+                    };
+                }
+            }
+            // Plan injection — find newest *.plan.md in session dir, append to last result
+            if (this.sessionDir != null &&
+                results.length > 0 &&
+                finalAnswer === null) {
+                try {
+                    const dir = this.sessionDir;
+                    if (fs.existsSync(dir)) {
+                        const planFiles = fs
+                            .readdirSync(dir)
+                            .filter((f) => f.endsWith(".plan.md"))
+                            .map((f) => ({
+                            name: f,
+                            mtime: fs.statSync(path.join(dir, f)).mtimeMs,
+                        }))
+                            .sort((a, b) => b.mtime - a.mtime);
+                        if (planFiles.length > 0) {
+                            const planPath = path.join(dir, planFiles[0].name);
+                            let planText = fs.readFileSync(planPath, "utf-8");
+                            if (planText.trim()) {
+                                const maxPc = this.config.maxPlanChars;
+                                if (planText.length > maxPc) {
+                                    planText =
+                                        planText.slice(0, maxPc) + "\n...[plan truncated]...";
+                                }
+                                const planBlock = `\n[SESSION PLAN file=${planFiles[0].name}]\n` +
+                                    `${planText}\n[/SESSION PLAN]\n`;
+                                const rl = results[results.length - 1];
+                                results[results.length - 1] = {
+                                    tool_call_id: rl.tool_call_id,
+                                    name: rl.name,
+                                    content: rl.content + planBlock,
+                                    is_error: rl.is_error,
+                                };
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // OSError equivalent – swallow
+                }
+            }
+            model.appendToolResults(conversation, results);
+            if (finalAnswer !== null) {
+                this._emit(`[d${depth}] completed in ${step} step(s)`, onEvent);
+                return finalAnswer;
+            }
+            for (const r of results) {
+                context.add(`[depth ${depth} step ${step}]\n${r.content}`);
+            }
+        }
+        return (`Step budget exhausted at depth ${depth} for objective: ${objective}\n` +
+            "Please try with a more specific task, higher step budget, or deeper recursion.");
+    }
+    // -----------------------------------------------------------------------
+    // Tool execution
+    // -----------------------------------------------------------------------
+    async _runOneTool(opts) {
+        const { tc, depth, step, objective, context, onEvent, onStep, deadline, currentModel, replayLogger, parallelGroupId = null, parallelOwner = null, } = opts;
+        const argSummary = summarizeArgs(tc.arguments);
+        this._emit(`[d${depth}/s${step}] ${tc.name}(${argSummary})`, onEvent);
+        const t1 = performance.now() / 1000;
+        let observation;
+        let isFinal;
+        const doApply = async () => {
+            try {
+                return await this._applyToolCall({
+                    toolCall: tc,
+                    depth,
+                    context,
+                    onEvent,
+                    onStep,
+                    deadline,
+                    currentModel,
+                    replayLogger,
+                    step,
+                });
+            }
+            catch (exc) {
+                const msg = `Tool ${tc.name} crashed: ${exc instanceof Error ? `${exc.constructor.name}: ${exc.message}` : String(exc)}`;
+                return [false, msg];
+            }
+        };
+        // Execution scope handling
+        if (parallelGroupId && parallelOwner) {
+            [isFinal, observation] = await this.tools.executionScopeAsync(parallelGroupId, parallelOwner, doApply);
+        }
+        else {
+            [isFinal, observation] = await doApply();
+        }
+        observation = this._clipObservation(observation);
+        const toolElapsed = performance.now() / 1000 - t1;
+        const obsSummary = summarizeObservation(observation);
+        this._emit(`[d${depth}/s${step}]   -> ${obsSummary} (${toolElapsed.toFixed(1)}s)`, onEvent);
+        if (onStep) {
+            try {
+                onStep({
+                    depth,
+                    step,
+                    objective,
+                    action: { name: tc.name, arguments: tc.arguments },
+                    observation,
+                    elapsed_sec: Math.round(toolElapsed * 100) / 100,
+                    is_final: isFinal,
+                });
+            }
+            catch {
+                // swallow
+            }
+        }
+        return [
+            {
+                tool_call_id: tc.id,
+                name: tc.name,
+                content: observation,
+                is_error: false,
+            },
+            isFinal,
+        ];
+    }
+    // -----------------------------------------------------------------------
+    // Tool dispatch
+    // -----------------------------------------------------------------------
+    async _applyToolCall(opts) {
+        const { toolCall, depth, context, onEvent, onStep, deadline = 0, currentModel = null, replayLogger = null, step = 0, } = opts;
+        const name = toolCall.name;
+        const args = toolCall.arguments;
+        const policyError = this._runtimePolicyCheck(name, args, depth);
+        if (policyError)
+            return [false, policyError];
+        // ----- think -----
+        if (name === "think") {
+            const note = String(args.note ?? "");
+            return [false, `Thought noted: ${note}`];
+        }
+        // ----- list_files -----
+        if (name === "list_files") {
+            const glob = args.glob != null ? String(args.glob) : undefined;
+            return [false, await this.tools.listFiles(glob)];
+        }
+        // ----- search_files -----
+        if (name === "search_files") {
+            const query = String(args.query ?? "").trim();
+            const glob = args.glob != null ? String(args.glob) : undefined;
+            if (!query)
+                return [false, "search_files requires non-empty query"];
+            return [false, await this.tools.searchFiles(query, glob)];
+        }
+        // ----- repo_map -----
+        if (name === "repo_map") {
+            const glob = args.glob != null ? String(args.glob) : undefined;
+            const rawMaxFiles = args.max_files ?? 200;
+            const maxFiles = typeof rawMaxFiles === "number" ? rawMaxFiles : 200;
+            return [false, await this.tools.repoMap(glob, maxFiles)];
+        }
+        // ----- web_search -----
+        if (name === "web_search") {
+            const query = String(args.query ?? "").trim();
+            if (!query)
+                return [false, "web_search requires non-empty query"];
+            const rawNumResults = args.num_results ?? 10;
+            const numResults = typeof rawNumResults === "number" ? rawNumResults : 10;
+            const rawIncludeText = args.include_text ?? false;
+            const includeText = typeof rawIncludeText === "boolean" ? rawIncludeText : false;
+            return [
+                false,
+                await this.tools.webSearch(query, numResults, includeText),
+            ];
+        }
+        // ----- fetch_url -----
+        if (name === "fetch_url") {
+            const urls = args.urls;
+            if (!Array.isArray(urls))
+                return [false, "fetch_url requires a list of URL strings"];
+            return [
+                false,
+                await this.tools.fetchUrl(urls.filter((u) => typeof u === "string")),
+            ];
+        }
+        // ----- read_file -----
+        if (name === "read_file") {
+            const filePath = String(args.path ?? "").trim();
+            if (!filePath)
+                return [false, "read_file requires path"];
+            const hashline = args.hashline != null ? args.hashline : true;
+            return [false, await this.tools.readFile(filePath, Boolean(hashline))];
+        }
+        // ----- write_file -----
+        if (name === "write_file") {
+            const filePath = String(args.path ?? "").trim();
+            if (!filePath)
+                return [false, "write_file requires path"];
+            const content = String(args.content ?? "");
+            return [false, await this.tools.writeFile(filePath, content)];
+        }
+        // ----- apply_patch -----
+        if (name === "apply_patch") {
+            const patch = String(args.patch ?? "");
+            if (!patch.trim())
+                return [false, "apply_patch requires non-empty patch"];
+            return [false, await this.tools.applyPatch(patch)];
+        }
+        // ----- edit_file -----
+        if (name === "edit_file") {
+            const filePath = String(args.path ?? "").trim();
+            if (!filePath)
+                return [false, "edit_file requires path"];
+            const oldText = String(args.old_text ?? "");
+            const newText = String(args.new_text ?? "");
+            if (!oldText)
+                return [false, "edit_file requires old_text"];
+            return [false, await this.tools.editFile(filePath, oldText, newText)];
+        }
+        // ----- hashline_edit -----
+        if (name === "hashline_edit") {
+            const filePath = String(args.path ?? "").trim();
+            if (!filePath)
+                return [false, "hashline_edit requires path"];
+            const edits = args.edits;
+            if (!Array.isArray(edits))
+                return [false, "hashline_edit requires edits array"];
+            return [false, await this.tools.hashlineEdit(filePath, edits)];
+        }
+        // ----- run_shell -----
+        if (name === "run_shell") {
+            const command = String(args.command ?? "").trim();
+            if (!command)
+                return [false, "run_shell requires command"];
+            const rawTimeout = args.timeout;
+            const timeout = rawTimeout != null ? Number(rawTimeout) : undefined;
+            return [false, await this.tools.runShell(command, timeout)];
+        }
+        // ----- run_shell_bg -----
+        if (name === "run_shell_bg") {
+            const command = String(args.command ?? "").trim();
+            if (!command)
+                return [false, "run_shell_bg requires command"];
+            return [false, this.tools.runShellBg(command)];
+        }
+        // ----- check_shell_bg -----
+        if (name === "check_shell_bg") {
+            const rawId = args.job_id;
+            if (rawId == null)
+                return [false, "check_shell_bg requires job_id"];
+            return [false, this.tools.checkShellBg(Number(rawId))];
+        }
+        // ----- kill_shell_bg -----
+        if (name === "kill_shell_bg") {
+            const rawId = args.job_id;
+            if (rawId == null)
+                return [false, "kill_shell_bg requires job_id"];
+            return [false, this.tools.killShellBg(Number(rawId))];
+        }
+        // ----- subtask -----
+        if (name === "subtask") {
+            if (!this.config.recursive)
+                return [false, "Subtask tool not available in flat mode."];
+            if (depth >= this.config.maxDepth)
+                return [false, "Max recursion depth reached; cannot run subtask."];
+            const subtaskObjective = String(args.objective ?? "").trim();
+            if (!subtaskObjective)
+                return [false, "subtask requires objective"];
+            const criteria = String(args.acceptance_criteria ?? "").trim();
+            if (this.config.acceptanceCriteria && !criteria) {
+                return [
+                    false,
+                    "subtask requires acceptance_criteria when acceptance criteria mode is enabled. " +
+                        "Provide specific, verifiable criteria for judging the result.",
+                ];
+            }
+            // Sub-model routing
+            const requestedModelName = args.model;
+            const requestedEffort = args.reasoning_effort;
+            let subtaskModel = null;
+            if ((requestedModelName || requestedEffort) &&
+                this.modelFactory) {
+                const cur = currentModel ?? this.model;
+                const curName = String(asRecord(cur).model ?? "");
+                const curEffort = asRecord(cur).reasoningEffort;
+                const curTier = modelTier(curName, curEffort);
+                const reqName = requestedModelName ?? curName;
+                const reqEffort = requestedEffort;
+                const reqTier = modelTier(reqName, reqEffort ?? curEffort);
+                if (reqTier < curTier) {
+                    return [
+                        false,
+                        `Cannot delegate to higher-tier model ` +
+                            `(current tier ${curTier}, requested tier ${reqTier}). ` +
+                            `Use an equal or lower-tier model.`,
+                    ];
+                }
+                const cacheKey = `${reqName}::${requestedEffort ?? ""}`;
+                if (!this._modelCache.has(cacheKey)) {
+                    this._modelCache.set(cacheKey, this.modelFactory(reqName, requestedEffort ?? null));
+                }
+                subtaskModel = this._modelCache.get(cacheKey);
+            }
+            this._emit(`[d${depth}] >> entering subtask: ${subtaskObjective}`, onEvent);
+            const childLogger = replayLogger
+                ? replayLogger.child(depth, step)
+                : null;
+            const subtaskResult = await this._solveRecursive({
+                objective: subtaskObjective,
+                depth: depth + 1,
+                context,
+                onEvent,
+                onStep,
+                onContentDelta: null,
+                deadline,
+                modelOverride: subtaskModel,
+                replayLogger: childLogger,
+            });
+            let observation = `Subtask result for '${subtaskObjective}':\n${subtaskResult}`;
+            if (criteria && this.config.acceptanceCriteria) {
+                const verdict = await this._judgeResult(subtaskObjective, criteria, subtaskResult, currentModel);
+                const tag = verdict.startsWith("PASS") ? "PASS" : "FAIL";
+                observation += `\n\n[ACCEPTANCE CRITERIA: ${tag}]\n${verdict}`;
+            }
+            return [false, observation];
+        }
+        // ----- execute -----
+        if (name === "execute") {
+            const executeObjective = String(args.objective ?? "").trim();
+            if (!executeObjective)
+                return [false, "execute requires objective"];
+            const criteria = String(args.acceptance_criteria ?? "").trim();
+            if (this.config.acceptanceCriteria && !criteria) {
+                return [
+                    false,
+                    "execute requires acceptance_criteria when acceptance criteria mode is enabled. " +
+                        "Provide specific, verifiable criteria for judging the result.",
+                ];
+            }
+            if (depth >= this.config.maxDepth)
+                return [false, "Max recursion depth reached; cannot run execute."];
+            // Resolve lowest-tier model for the executor.
+            const cur = currentModel ?? this.model;
+            const curName = String(asRecord(cur).model ?? "");
+            const [execName, execEffort] = lowestTierModel(curName);
+            let execModel = null;
+            if (this.modelFactory) {
+                const cacheKey = `${execName}::${execEffort ?? ""}`;
+                if (!this._modelCache.has(cacheKey)) {
+                    this._modelCache.set(cacheKey, this.modelFactory(execName, execEffort));
+                }
+                execModel = this._modelCache.get(cacheKey);
+            }
+            // Give executor full tools (no subtask, no execute).
+            let savedDefs = undefined;
+            if (execModel && "toolDefs" in execModel) {
+                asRecord(execModel).toolDefs = get_tool_definitions({
+                    includeSubtask: false,
+                    includeAcceptanceCriteria: this.config.acceptanceCriteria,
+                });
+            }
+            else if (execModel === null && "toolDefs" in cur) {
+                savedDefs = asRecord(cur).toolDefs;
+                asRecord(cur).toolDefs = get_tool_definitions({
+                    includeSubtask: false,
+                    includeAcceptanceCriteria: this.config.acceptanceCriteria,
+                });
+            }
+            this._emit(`[d${depth}] >> executing leaf: ${executeObjective}`, onEvent);
+            const childLogger = replayLogger
+                ? replayLogger.child(depth, step)
+                : null;
+            const execResult = await this._solveRecursive({
+                objective: executeObjective,
+                depth: depth + 1,
+                context,
+                onEvent,
+                onStep,
+                onContentDelta: null,
+                deadline,
+                modelOverride: execModel,
+                replayLogger: childLogger,
+            });
+            if (savedDefs !== undefined) {
+                asRecord(cur).toolDefs = savedDefs;
+            }
+            let observation = `Execute result for '${executeObjective}':\n${execResult}`;
+            if (criteria && this.config.acceptanceCriteria) {
+                const verdict = await this._judgeResult(executeObjective, criteria, execResult, currentModel);
+                const tag = verdict.startsWith("PASS") ? "PASS" : "FAIL";
+                observation += `\n\n[ACCEPTANCE CRITERIA: ${tag}]\n${verdict}`;
+            }
+            return [false, observation];
+        }
+        // ----- list_artifacts -----
+        if (name === "list_artifacts") {
+            return [false, this._listArtifacts()];
+        }
+        // ----- read_artifact -----
+        if (name === "read_artifact") {
+            const aid = String(args.artifact_id ?? "").trim();
+            if (!aid)
+                return [false, "read_artifact requires artifact_id"];
+            const offset = Number(args.offset ?? 0) || 0;
+            const limit = Number(args.limit ?? 100) || 100;
+            return [false, this._readArtifact(aid, offset, limit)];
+        }
+        // ----- Domain-specific tools (tools/ directory) -----
+        if (name in WorkspaceTools._DOMAIN_TOOL_SCRIPTS) {
+            return [false, await this.tools.runDomainTool(name, args)];
+        }
+        return [false, `Unknown action type: ${name}`];
+    }
+    // -----------------------------------------------------------------------
+    // Artifact helpers
+    // -----------------------------------------------------------------------
+    /** List available artifacts. */
+    _listArtifacts() {
+        const artifactsDir = path.join(this.config.workspace, ".openplanter_artifacts");
+        if (!fs.existsSync(artifactsDir))
+            return "No artifacts found.";
+        let entries;
+        try {
+            entries = fs
+                .readdirSync(artifactsDir)
+                .filter((f) => f.endsWith(".jsonl"))
+                .sort();
+        }
+        catch {
+            return "No artifacts found.";
+        }
+        if (entries.length === 0)
+            return "No artifacts found.";
+        const lines = [];
+        for (const entry of entries) {
+            try {
+                const filePath = path.join(artifactsDir, entry);
+                const firstLine = fs
+                    .readFileSync(filePath, "utf-8")
+                    .split("\n", 1)[0];
+                const first = JSON.parse(firstLine);
+                const artifactId = String(first.artifact_id ?? entry.replace(/\.jsonl$/, ""));
+                const obj = String(first.objective ?? "(no objective)").slice(0, 120);
+                lines.push(`- ${artifactId}: ${obj}`);
+            }
+            catch {
+                lines.push(`- ${entry.replace(/\.jsonl$/, "")}: (unreadable)`);
+            }
+        }
+        return `Artifacts (${lines.length}):\n${lines.join("\n")}`;
+    }
+    /** Read an artifact's conversation log. */
+    _readArtifact(artifactId, offset = 0, limit = 100) {
+        const artifactsDir = path.join(this.config.workspace, ".openplanter_artifacts");
+        const filePath = path.join(artifactsDir, `${artifactId}.jsonl`);
+        if (!fs.existsSync(filePath))
+            return `Artifact '${artifactId}' not found.`;
+        const allLines = fs.readFileSync(filePath, "utf-8").split("\n");
+        // Remove trailing empty line if any
+        if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
+            allLines.pop();
+        }
+        const total = allLines.length;
+        const selected = allLines.slice(offset, offset + limit);
+        const header = `Artifact ${artifactId} (lines ${offset}-${offset + selected.length} of ${total}):\n`;
+        return header + selected.join("\n");
+    }
+}
+//# sourceMappingURL=engine.js.map