deepclause-sdk 0.0.88 → 0.1.0

package/dist/runner.js

@@ -1,21 +1,19 @@
 /**
  * DML Runner - Executes DML code using SWI-Prolog WASM
  */
-import * as fs from 'fs/promises';
-import * as path from 'path';
 import { mountWorkspace } from './prolog/loader.js';
 import { runAgentLoop } from './agent.js';
-import { executeCompactor, getCompactionBindings, resolveCompactionOptions, } from './compaction.js';
+import { judgeAnswersToValues, judgeCacheKey, normalizeJudgeState, parseJudgeQuestions, validateJudgeAnswers, valuesToPrologList } from './judge/marshal.js';
 import { buildToolCompletionEvent, buildToolFailureEvent, buildToolStartEvent, } from './system/runtime/shell-tool-events.js';
 import { checkToolPolicy } from './tools.js';
 import { generateLlmReply, sampleSingleToken } from './prolog/bridge.js';
-import { recordTokenUsage } from './system/runtime/token-usage.js';
 import { buildReasoningProviderOptions } from './system/config/model-database.js';
+import { resolveMediaRefs } from './system/runtime/media.js';
 /**
  * Convert swipl-wasm value to plain JavaScript value
  * Handles PrologString, PrologAtom, PrologList, etc.
  */
-function toJsValue(value) {
+export function toJsValue(value) {
     if (value === null || value === undefined) {
         return value;
     }
@@ -59,45 +57,45 @@ function toJsValue(value) {
     }
     return value;
 }
-function detectProvider(model) {
-    const lower = model.toLowerCase();
-    if (lower.includes('gpt') || lower.includes('o1') || lower.includes('o3')) {
-        return 'openai';
-    }
-    if (lower.includes('claude')) {
-        return 'anthropic';
-    }
-    if (lower.includes('gemini') || lower.includes('palm')) {
-        return 'google';
+/**
+ * Decode the `bindings` payload of a goal-mode `solution` event.
+ *
+ * `collect_bindings/2` yields a list of `Name-Text` pairs. swipl-wasm encodes
+ * that compound as `{ '$t': 't', '-': [[Name, Text]] }`; a dict/array form is
+ * also accepted for forward compatibility.
+ */
+export function decodeSolutionBindings(raw) {
+    const normalized = toJsValue(raw);
+    if (!Array.isArray(normalized)) {
+        return [];
     }
-    return 'openrouter';
-}
-function createChildAbortController(parentSignal, timeoutMs) {
-    const controller = new AbortController();
-    const disposers = [];
-    if (parentSignal) {
-        if (parentSignal.aborted) {
-            controller.abort(parentSignal.reason);
+    const bindings = [];
+    for (const item of normalized) {
+        const decoded = toJsValue(item);
+        if (decoded && typeof decoded === 'object') {
+            const compound = decoded;
+            const args = compound['-'];
+            if (Array.isArray(args) && Array.isArray(args[0]) && args[0].length >= 2) {
+                const [name, text] = args[0];
+                bindings.push({ name: String(toJsValue(name) ?? ''), value: String(toJsValue(text) ?? '') });
+                continue;
+            }
+            if ('name' in compound || 'value' in compound) {
+                bindings.push({
+                    name: String(toJsValue(compound.name) ?? ''),
+                    value: String(toJsValue(compound.value) ?? ''),
+                });
+                continue;
+            }
         }
-        else {
-            const onAbort = () => controller.abort(parentSignal.reason);
-            parentSignal.addEventListener('abort', onAbort, { once: true });
-            disposers.push(() => parentSignal.removeEventListener('abort', onAbort));
+        if (Array.isArray(decoded) && decoded.length >= 2) {
+            bindings.push({
+                name: String(toJsValue(decoded[0]) ?? ''),
+                value: String(toJsValue(decoded[1]) ?? ''),
+            });
         }
     }
-    let timeout;
-    if (timeoutMs > 0) {
-        timeout = setTimeout(() => controller.abort(new Error(`Compactor timed out after ${timeoutMs}ms`)), timeoutMs);
-        disposers.push(() => clearTimeout(timeout));
-    }
-    return {
-        signal: controller.signal,
-        dispose: () => {
-            for (const dispose of disposers) {
-                dispose();
-            }
-        },
-    };
+    return bindings;
 }
 export function decodeAgentOutputVars(rawOutputVars) {
     const normalized = toJsValue(rawOutputVars);
@@ -141,10 +139,18 @@ function prologTypeToJsonType(prologType) {
 export class DMLRunner {
     swipl;
     options;
-    engine = null;
     sessionId = '';
     currentMemory = [];
     stepCounter = 0;
+    judgeCache = new Map();
+    /**
+     * Runner-owned frame table: FrameId -> { frame, engine }.
+     * The Prolog session owns the authoritative engine handles
+     * (session_frame_engine/2); this map mirrors them for the driver.
+     */
+    frames = new Map();
+    /** FrameId of the session's default query frame (created by createEngine). */
+    defaultFrameId = null;
     constructor(swipl, options) {
         this.swipl = swipl;
         this.options = options;
@@ -162,6 +168,7 @@ export class DMLRunner {
         // Generate unique session ID
         this.sessionId = `sess_${Date.now()}_${Math.random().toString(36).slice(2)}`;
         const memoryId = `mem_${this.sessionId}`; // Kept for API compatibility
+        this.judgeCache.clear();
         try {
             // Mount workspace if path provided
             if (options.workspacePath) {
@@ -188,91 +195,18 @@ export class DMLRunner {
                 yield { type: 'error', content: parseResult.error };
                 return;
             }
-            // Create cooperative engine with args
+            // Create cooperative engine with args (registers the default query frame)
             const engineResult = this.createEngine(memoryId, args, params);
             if (engineResult.error) {
                 yield { type: 'error', content: engineResult.error };
                 return;
             }
-            // Cooperative execution loop
-            while (true) {
-                // Check for abort
-                if (options.signal?.aborted) {
-                    const reason = options.signal.reason;
-                    const abortMessage = reason instanceof Error
-                        ? reason.message
-                        : typeof reason === 'string' && reason.trim().length > 0
-                            ? reason
-                            : 'Execution aborted';
-                    yield { type: 'error', content: abortMessage };
-                    break;
-                }
-                // Step the engine
-                const step = this.stepEngine();
-                if (process.env.DEBUG_STEPS) {
-                    console.log('[MAIN_LOOP] step:', step.status, step.content?.substring(0, 50));
-                }
-                switch (step.status) {
-                    case 'output':
-                        if (step.content) {
-                            if (process.env.DEBUG_STEPS) {
-                                console.log('[MAIN_LOOP] yielding output:', step.content.substring(0, 50));
-                            }
-                            yield { type: 'output', content: step.content };
-                        }
-                        break;
-                    case 'log':
-                        if (step.content) {
-                            yield { type: 'log', content: step.content };
-                        }
-                        break;
-                    case 'answer':
-                        yield { type: 'answer', content: step.content };
-                        break;
-                    case 'request_agent_loop':
-                        // Run agent loop for task() predicate
-                        yield* this.handleAgentLoop(step.payload, memoryId, options);
-                        break;
-                    case 'request_exec':
-                        // Execute external tool
-                        yield* this.handleExec(step.payload, options);
-                        break;
-                    case 'request_sample_token':
-                        yield* this.handleSampleToken(step.payload, options);
-                        break;
-                    case 'request_llm':
-                        yield* this.handleLlm(step.payload, options);
-                        break;
-                    case 'wait_input':
-                        // Request user input
-                        yield { type: 'input_required', prompt: step.prompt };
-                        const input = await options.onInputRequired(step.prompt ?? '');
-                        this.provideInput(input);
-                        break;
-                    case 'finished':
-                        // Include trace data if trace mode was enabled
-                        if (this.options.trace && step.payload) {
-                            const traceData = toJsValue(step.payload.trace);
-                            yield { type: 'finished', trace: Array.isArray(traceData) ? traceData : undefined };
-                        }
-                        else {
-                            yield { type: 'finished' };
-                        }
-                        return;
-                    case 'error':
-                        if (this.options.trace && step.payload) {
-                            const traceData = toJsValue(step.payload.trace);
-                            yield { type: 'error', content: step.content, trace: Array.isArray(traceData) ? traceData : undefined };
-                        }
-                        else {
-                            yield { type: 'error', content: step.content };
-                        }
-                        return;
-                    default:
-                        yield { type: 'error', content: `Unknown step status: ${step.status}` };
-                        return;
-                }
+            const frame = this.defaultFrameId ? this.frames.get(this.defaultFrameId)?.frame : undefined;
+            if (!frame) {
+                yield { type: 'error', content: 'Failed to register default query frame' };
+                return;
             }
+            yield* this.stepLoop(frame, options);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -283,6 +217,164 @@ export class DMLRunner {
             this.cleanup();
         }
     }
+    /**
+     * Drive a single frame until it finishes or errors, yielding its events.
+     *
+     * This is the extracted, reentrant form of the original `while(true)` loop.
+     * `run()` calls it for the default query frame; `runFrame` calls it for
+     * nested frames. Because frames are read from the Prolog frame table via
+     * `step_frame/4`, stepping a different frame never disturbs a suspended
+     * parent's engine.
+     */
+    async *stepLoop(frame, options) {
+        for await (const event of this.stepLoopInner(frame, options)) {
+            // Preserve frame metadata already attached by a nested frame; otherwise
+            // stamp this frame so the renderer can attribute output correctly.
+            yield {
+                ...event,
+                frameId: event.frameId ?? frame.id,
+                depth: event.depth ?? frame.depth,
+                frameKind: event.frameKind ?? frame.kind,
+            };
+        }
+    }
+    async *stepLoopInner(frame, options) {
+        // Cooperative execution loop
+        while (true) {
+            // Check for abort
+            if (options.signal?.aborted) {
+                const reason = options.signal.reason;
+                const abortMessage = reason instanceof Error
+                    ? reason.message
+                    : typeof reason === 'string' && reason.trim().length > 0
+                        ? reason
+                        : 'Execution aborted';
+                yield { type: 'error', content: abortMessage };
+                break;
+            }
+            // Step the frame
+            const step = this.stepFrame(frame.id);
+            if (process.env.DEBUG_STEPS) {
+                console.log('[MAIN_LOOP] step:', step.status, step.content?.substring(0, 50));
+            }
+            switch (step.status) {
+                case 'output':
+                    if (step.content) {
+                        if (process.env.DEBUG_STEPS) {
+                            console.log('[MAIN_LOOP] yielding output:', step.content.substring(0, 50));
+                        }
+                        yield { type: 'output', content: step.content };
+                    }
+                    break;
+                case 'log':
+                    if (step.content) {
+                        yield { type: 'log', content: step.content };
+                    }
+                    break;
+                case 'answer':
+                    yield { type: 'answer', content: step.content };
+                    break;
+                case 'solution': {
+                    const payload = (step.payload ?? {});
+                    yield {
+                        type: 'solution',
+                        solution: {
+                            bindings: decodeSolutionBindings(payload.bindings),
+                            deterministic: String(toJsValue(payload.deterministic) ?? 'false') === 'true',
+                        },
+                    };
+                    break;
+                }
+                case 'request_agent_loop':
+                    // Run agent loop for task() predicate. The frame kind decides the
+                    // tool set: `meta` frames get the host meta tools and hide the
+                    // harness's own DML tools (proposal §9.2). Budget exhaustion (and any
+                    // other agent-loop error) is surfaced as an error event.
+                    try {
+                        yield* this.handleAgentLoop(step.payload, '', options, frame);
+                    }
+                    catch (error) {
+                        yield { type: 'error', content: error instanceof Error ? error.message : String(error) };
+                        return;
+                    }
+                    break;
+                case 'meta_result': {
+                    const payload = (step.payload ?? {});
+                    yield {
+                        type: 'meta_result',
+                        metaResult: {
+                            code: String(toJsValue(payload.code) ?? ''),
+                            answer: String(toJsValue(payload.answer) ?? ''),
+                        },
+                    };
+                    break;
+                }
+                case 'request_exec':
+                    // Execute external tool
+                    yield* this.handleExec(step.payload, options);
+                    break;
+                case 'request_sample_token':
+                    yield* this.handleSampleToken(step.payload, options);
+                    break;
+                case 'request_llm':
+                    yield* this.handleLlm(step.payload, options);
+                    break;
+                case 'request_judgment':
+                    yield* this.handleJudgment(step.payload, options);
+                    break;
+                case 'wait_input': {
+                    // Request user input
+                    yield { type: 'input_required', prompt: step.prompt };
+                    const input = await options.onInputRequired(step.prompt ?? '');
+                    if (input === undefined || input === null) {
+                        this.cancelInput();
+                    }
+                    else {
+                        this.provideInput(input);
+                    }
+                    break;
+                }
+                case 'finished':
+                    // Include trace data if trace mode was enabled
+                    if (this.options.trace && step.payload) {
+                        const traceData = toJsValue(step.payload.trace);
+                        yield { type: 'finished', trace: Array.isArray(traceData) ? traceData : undefined };
+                    }
+                    else {
+                        yield { type: 'finished' };
+                    }
+                    return;
+                case 'error':
+                    if (this.options.trace && step.payload) {
+                        const traceData = toJsValue(step.payload.trace);
+                        yield { type: 'error', content: step.content, trace: Array.isArray(traceData) ? traceData : undefined };
+                    }
+                    else {
+                        yield { type: 'error', content: step.content };
+                    }
+                    return;
+                default:
+                    yield { type: 'error', content: `Unknown step status: ${step.status}` };
+                    return;
+            }
+        }
+    }
+    /**
+     * Run a specific frame to completion, yielding its events.
+     *
+     * This is the reentrant entry point used by nested execution (the REPL's
+     * `execute` meta tool): the caller builds a child frame with
+     * `createNestedFrame`, runs it with this method while the parent frame is
+     * suspended, then posts the result back to the parent.
+     */
+    async *runFrame(frameId, options) {
+        const frame = this.frames.get(frameId)?.frame;
+        if (!frame) {
+            yield { type: 'error', content: `Unknown frame: ${frameId}` };
+            return;
+        }
+        yield* this.stepLoop(frame, options);
+    }
     /**
      * Parse DML code into Prolog clauses
      */
@@ -375,10 +467,15 @@ export class DMLRunner {
     createEngine(memoryId, args, params) {
         try {
             const initialMemory = this.serializeMemoryMessages(this.currentMemory);
-            const result = this.query(`deepclause_mi:create_engine('${this.sessionId}', '${memoryId}', ${args}, ${params}, [${initialMemory}], Engine)`);
-            if (result && result.Engine) {
-                this.engine = result.Engine;
-                return {};
+            // create_engine/6 registers the default `query` frame; default_frame/2
+            // returns its FrameId so the runner can address it explicitly.
+            const result = this.query(`deepclause_mi:create_engine('${this.sessionId}', '${memoryId}', ${args}, ${params}, [${initialMemory}], Engine), deepclause_mi:default_frame('${this.sessionId}', FrameId)`);
+            if (result && result.Engine && result.FrameId) {
+                const frameId = String(toJsValue(result.FrameId));
+                const frame = { id: frameId, kind: 'query', depth: 0 };
+                this.frames.set(frameId, { frame, engine: result.Engine });
+                this.defaultFrameId = frameId;
+                return { frameId };
             }
             return { error: 'Failed to create engine' };
         }
@@ -388,11 +485,93 @@ export class DMLRunner {
         }
     }
     /**
-     * Step the cooperative engine
+     * Create a nested frame that runs a Prolog goal in this session.
+     *
+     * `goalTerm` is inserted verbatim into create_frame/6, so callers MUST pass
+     * a term built with the runner's `toPrologTerm` escaping or parsed from DML
+     * via `read_term` — never raw user text (foot gun #18). `stateTerm` is an
+     * optional Prolog `state{...}` term; the default is an empty state with no
+     * gas limit.
+     *
+     * Returns the registered frame, or null on failure. The caller is
+     * responsible for running (`runFrame`) and ending (`endFrame`) it.
      */
-    stepEngine() {
+    createNestedFrame(params) {
+        const depth = params.depth ?? 1;
+        const stateTerm = params.stateTerm
+            ?? 'state{memory: [], params: params{}, context_stack: [], depth: 0}';
+        const result = this.query(`deepclause_mi:create_frame('${this.sessionId}', ${params.kind}, ${depth}, ${params.goalTerm}, ${stateTerm}, FrameId)`);
+        if (!result || !result.FrameId) {
+            return null;
+        }
+        const id = String(toJsValue(result.FrameId));
+        const frame = { id, kind: params.kind, depth };
+        this.frames.set(id, { frame, engine: null });
+        return frame;
+    }
+    /** End a frame, destroying its engine in the Prolog session. */
+    endFrame(frameId) {
+        this.query(`deepclause_mi:end_frame('${frameId}')`);
+        this.frames.delete(frameId);
+        if (this.defaultFrameId === frameId) {
+            this.defaultFrameId = null;
+        }
+    }
+    /**
+     * Bind this runner to an existing session id. Used by the REPL's
+     * DMLSession, whose session outlives a single `run()`.
+     */
+    bindSession(sessionId) {
+        this.sessionId = sessionId;
+    }
+    /**
+     * Adopt the session's default frame (for example one created by the REPL's
+     * `query_start/5`) into the runner's frame table so `runFrame` can drive it.
+     */
+    registerDefaultFrame(kind, depth = 0) {
+        const result = this.query(`deepclause_mi:default_frame('${this.sessionId}', FrameId)`);
+        if (!result || !result.FrameId) {
+            return null;
+        }
+        const id = String(toJsValue(result.FrameId));
+        const frame = { id, kind, depth };
+        this.frames.set(id, { frame, engine: null });
+        this.defaultFrameId = id;
+        return frame;
+    }
+    /**
+     * Adopt a Prolog-created frame into the runner's frame table. Used by the
+     * REPL for `execute` child frames (`repl_execute_frame/4`).
+     */
+    registerFrame(frameId, kind, depth = 0) {
+        const frame = { id: frameId, kind, depth };
+        this.frames.set(frameId, { frame, engine: null });
+        return frame;
+    }
+    /**
+     * Drop all runner-side frame bookkeeping without touching Prolog. Used after
+     * the REPL clears a session (the Prolog side already ended every frame).
+     */
+    clearFrames() {
+        this.frames.clear();
+        this.defaultFrameId = null;
+    }
+    /**
+     * Step a specific frame exactly once and return its raw step result.
+     * Used by the reentrant driver and nested-execution tests.
+     */
+    stepFrameOnce(frameId) {
+        if (!this.frames.has(frameId)) {
+            return null;
+        }
+        return this.stepFrame(frameId);
+    }
+    /**
+     * Step the cooperative engine for a frame
+     */
+    stepFrame(frameId) {
         try {
-            const result = this.query(`deepclause_mi:step_engine('${this.sessionId}', Status, Content, Payload)`);
+            const result = this.query(`deepclause_mi:step_frame('${frameId}', Status, Content, Payload)`);
             // Convert swipl-wasm values to plain JS
             const status = toJsValue(result?.Status);
             const content = toJsValue(result?.Content);
@@ -413,13 +592,15 @@ export class DMLRunner {
      * Handle agent loop request (task() predicate)
      */
     async *handleAgentLoop(payload, _memoryId, // No longer used - memory comes from payload
-    options) {
+    options, _frame) {
         const rawPayload = payload;
         const taskDescription = String(toJsValue(rawPayload.taskDescription) ?? '');
         const stepId = `step_${this.stepCounter++}`;
         yield { type: 'task_activity', taskState: 'started', taskDescription, taskId: stepId };
         let stepSucceeded = null;
         try {
+            // The per-model-call budget is enforced inside the agent loop (before each
+            // model call) so it also covers multi-iteration turns.
             // Ensure outputVars is an array of either strings or TypedVar objects
             const outputVars = decodeAgentOutputVars(rawPayload.outputVars);
             // Parse userTools - now contains schema info as array of tool_info dicts
@@ -497,6 +678,9 @@ export class DMLRunner {
                         try {
                             emitToolEvent({ type: 'input_required', prompt });
                             const response = await options.onInputRequired(prompt);
+                            if (response === undefined || response === null) {
+                                return { cancelled: true };
+                            }
                             return { user_response: response };
                         }
                         catch (err) {
@@ -509,15 +693,15 @@ export class DMLRunner {
             const emitToolCall = (toolName, args) => {
                 emitToolEvent({ type: 'tool_call', toolName, toolArgs: args });
             };
-            // Build available tools for agent - SIMPLIFIED: tools run in isolated engines
-            const availableTools = this.buildAgentTools(userTools, options.toolPolicy, 
-            // executeToolIsolated callback - runs tool in separate engine (no state sharing)
-            async (toolName, args) => {
+            // Build available tools for the agent: the harness's DML tool/2 predicates
+            // plus registered TS tools (reachable via exec/2).
+            const selfReportingTools = undefined;
+            const availableTools = this.buildAgentTools(userTools, options.toolPolicy, async (toolName, args) => {
                 return this.executeToolIsolated(toolName, args, augmentedTools, onToolOutput, {
                     workspacePath: options.workspacePath,
                     signal: options.signal,
-                    compaction: options.compaction,
                     toolPolicy: options.toolPolicy,
+                    onModelCall: options.onModelCall,
                 }, [], emitToolCall, emitToolEvent);
             });
             // Run agent loop with streaming support
@@ -527,6 +711,7 @@ export class DMLRunner {
                 memory: effectiveMemory,
                 tools: availableTools,
                 workspacePath: options.workspacePath,
+                resolveMedia: (refs) => this.readMediaRefs(options.workspacePath, refs),
                 modelOptions: {
                     model: this.options.model,
                     provider: this.options.provider,
@@ -545,6 +730,13 @@ export class DMLRunner {
                         streamResolve = null;
                     }
                 },
+                onReasoning: (chunk, done) => {
+                    streamQueue.push({ type: 'reasoning', content: chunk, done });
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
+                    }
+                },
                 onToolCall: (toolName, args) => {
                     streamQueue.push({ type: 'tool_call', toolName, toolArgs: args });
                     if (streamResolve) {
@@ -559,23 +751,29 @@ export class DMLRunner {
                         streamResolve = null;
                     }
                 },
-                onBeforeModelCall: async (messages, lastInputTokens) => this.applyCompactionBindings({
-                    messages,
-                    lastInputTokens,
-                    scope: 'loop',
-                    trigger: 'before_model_call',
-                    options,
-                    executionContext: {
-                        workspacePath: options.workspacePath,
-                        signal: options.signal,
-                        compaction: options.compaction,
-                    },
-                    registeredTools: options.tools,
-                    toolPolicy: options.toolPolicy,
-                    emitEvent: emitRunnerEvent,
-                }),
+                onModelCallPhase: (phase) => {
+                    streamQueue.push({ type: 'model_call', modelCallState: phase, modelId: this.options.model });
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
+                    }
+                },
+                selfReportingTools,
+                onToolResult: (toolName, toolArgs, toolResult) => {
+                    streamQueue.push(buildToolCompletionEvent(toolName, toolArgs, toolResult));
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
+                    }
+                },
+                onBeforeModelCall: async (messages, lastInputTokens) => {
+                    const hostCompacted = await this.applyHostCompaction(messages, lastInputTokens, emitRunnerEvent);
+                    return hostCompacted ?? messages;
+                },
                 onAskUser: options.onInputRequired,
+                onModelCall: options.onModelCall,
                 signal: options.signal,
+                llmBackend: this.options.llmBackend,
             });
             // Yield streaming events as they arrive
             if (this.options.streaming) {
@@ -683,6 +881,7 @@ export class DMLRunner {
                     providerOptions: this.options.providerOptions,
                 },
                 signal: options.signal,
+                llmBackend: this.options.llmBackend,
             });
             succeeded = true;
             this.postSampleTokenResult({ success: true, token });
@@ -721,6 +920,8 @@ export class DMLRunner {
                     providerOptions: this.options.providerOptions,
                 },
                 signal: options.signal,
+                llmBackend: this.options.llmBackend,
+                resolveMedia: (refs) => this.readMediaRefs(options.workspacePath, refs),
             });
             succeeded = true;
             this.postLlmResult({ success: true, text });
@@ -737,20 +938,132 @@ export class DMLRunner {
             yield { type: 'task_activity', taskState: succeeded ? 'completed' : 'failed', taskId: stepId };
         }
     }
+    /**
+     * Handle a semantic judgment request (judge/2 and the one-off predicates).
+     */
+    async *handleJudgment(payload, options) {
+        const parsed = this.parseJudgmentPayload(payload);
+        const ids = parsed.questions.map((question) => question.id);
+        const backendName = parsed.requestedName === 'default'
+            ? options.judgeBackend ?? this.options.judgeSelection?.defaultName ?? 'llm'
+            : parsed.requestedName;
+        const stepId = `judge_${this.stepCounter++}`;
+        yield {
+            type: 'task_activity',
+            taskState: 'started',
+            taskDescription: `judge[${backendName}]: ${ids.join(', ')}`,
+            taskId: stepId,
+            judgeBackend: backendName,
+            judgeQuestionIds: ids,
+            judgeState: 'started',
+        };
+        const result = await this.completeJudgment(parsed, { signal: options.signal, judgeBackend: options.judgeBackend });
+        if (result.error) {
+            this.postJudgmentResult({ success: false, error: result.error });
+            yield { type: 'log', content: `judgment failed: ${result.error}` };
+        }
+        else {
+            this.postJudgmentResult({ success: true, values: result.values ?? [] });
+            if (result.usage) {
+                yield {
+                    type: 'usage',
+                    usage: {
+                        inputTokens: result.usage.inputTokens,
+                        outputTokens: result.usage.outputTokens,
+                        totalTokens: result.usage.totalTokens ?? result.usage.inputTokens + result.usage.outputTokens,
+                    },
+                    usageSource: 'judge',
+                    usageModel: result.usageModel,
+                };
+            }
+        }
+        yield {
+            type: 'task_activity',
+            taskState: result.error ? 'failed' : 'completed',
+            taskId: stepId,
+            judgeBackend: result.backendName,
+            judgeQuestionIds: result.ids,
+            judgeState: result.error ? 'failed' : 'completed',
+        };
+    }
+    parseJudgmentPayload(payload) {
+        const data = (payload ?? {});
+        return {
+            questions: parseJudgeQuestions(data.questions),
+            state: normalizeJudgeState(data.state),
+            requiredCapabilities: Array.isArray(data.requires) ? data.requires.map(String) : [],
+            requestedName: typeof data.backend === 'string' ? data.backend : 'default',
+        };
+    }
+    async completeJudgment(parsed, context) {
+        const selection = this.options.judgeSelection;
+        const defaultName = context.judgeBackend ?? selection?.defaultName ?? 'llm';
+        const backendName = parsed.requestedName === 'default' ? defaultName : parsed.requestedName;
+        const ids = parsed.questions.map((question) => question.id);
+        try {
+            const backend = selection?.backends.get(backendName);
+            if (!backend)
+                throw new Error(`Unknown judgment backend: ${backendName}`);
+            const missing = parsed.requiredCapabilities.filter((capability) => !backend.capabilities[capability]);
+            if (missing.length > 0) {
+                throw new Error(`Judgment backend '${backendName}' lacks required capabilities: ${missing.join(', ')}`);
+            }
+            const model = this.options.model;
+            const key = judgeCacheKey(backend.id, model, parsed.state, parsed.questions);
+            const cached = this.judgeCache.get(key);
+            if (cached) {
+                return { backendName, ids, values: judgeAnswersToValues(parsed.questions, cached) };
+            }
+            const response = await backend.complete({
+                state: parsed.state,
+                questions: parsed.questions,
+                signal: context.signal,
+                model,
+                requiredCapabilities: parsed.requiredCapabilities,
+            });
+            const answers = validateJudgeAnswers(parsed.questions, response.answers);
+            this.judgeCache.set(key, answers);
+            return {
+                backendName,
+                ids,
+                values: judgeAnswersToValues(parsed.questions, answers),
+                usage: response.usage,
+                usageModel: response.model ?? model,
+            };
+        }
+        catch (error) {
+            return {
+                backendName,
+                ids,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    postJudgmentResult(result) {
+        if (result.success) {
+            this.query(`deepclause_mi:post_judgment_result('${this.sessionId}', success, ${valuesToPrologList(result.values ?? [])})`);
+        }
+        else {
+            this.query(`deepclause_mi:post_judgment_result('${this.sessionId}', failure, ${this.toPrologTerm(result.error ?? 'Unknown error')})`);
+        }
+    }
     /**
      * Handle exec request (exec() predicate)
      */
     async *handleExec(payload, options) {
         const { toolName, args } = payload;
-        // Check tool policy
+        // Check tool policy (ask_user is the human channel and is exempt).
         const policyCheck = checkToolPolicy(toolName, options.toolPolicy);
         if (!policyCheck.allowed) {
             yield { type: 'log', content: `Tool '${toolName}' blocked by policy: ${policyCheck.reason}` };
             this.postExecResult({ success: false, error: policyCheck.reason });
             return;
         }
-        // Get tool definition
-        const tool = options.tools.get(toolName);
+        // Get tool definition. `ask_user` is SDK-internal so exec(ask_user(...))
+        // works in DML even when no capability tools are registered.
+        const tool = toolName === 'ask_user'
+            ? this.internalAskUserTool(options)
+            : options.tools.get(toolName);
         if (!tool) {
             yield { type: 'log', content: `Tool '${toolName}' not found` };
             this.postExecResult({ success: false, error: `Tool not found: ${toolName}` });
@@ -762,7 +1075,7 @@ export class DMLRunner {
             argsObj = this.argsToObject(args, tool);
             // Emit tool_call event before execution
             yield buildToolStartEvent(toolName, argsObj);
-            const result = await tool.execute(argsObj);
+            const result = await tool.execute(argsObj, { signal: options.signal });
             yield buildToolCompletionEvent(toolName, argsObj, result);
             // Post result back to Prolog
             this.postExecResult({ success: true, result });
@@ -934,16 +1247,14 @@ export class DMLRunner {
      * Only includes tools defined in DML - registered TypeScript tools are NOT exposed to the LLM.
      * DML tools can internally call exec/2 to use registered tools.
      */
-    buildAgentTools(userTools, policy, executeToolInline) {
+    buildAgentTools(userTools, _policy, executeToolInline) {
         const result = new Map();
         // Add user-defined tools from DML file with schema info
         // These are the ONLY tools the LLM can call during task()
+        // Do not apply the host runtime-tool policy to these DML predicates. Their
+        // nested exec/2 calls pass through handleExec/executeToolIsolated, where
+        // the policy still restricts actual host capabilities.
         for (const tool of userTools) {
-            // Check policy for DML tools too
-            const check = checkToolPolicy(tool.name, policy);
-            if (!check.allowed) {
-                continue;
-            }
             // Build JSON Schema properties from inputs
             const properties = {};
             const required = [];
@@ -1057,7 +1368,7 @@ export class DMLRunner {
                             try {
                                 argsObj = this.argsToObject(execArgs, tool);
                                 onToolEvent?.(buildToolStartEvent(execToolName, argsObj));
-                                const execResult = await tool.execute(argsObj);
+                                const execResult = await tool.execute(argsObj, { signal: runContext.signal });
                                 onToolEvent?.(buildToolCompletionEvent(execToolName, argsObj, execResult));
                                 const postGoal = `deepclause_mi:post_exec_result('${this.sessionId}', success, ${this.toPrologTerm(execResult)})`;
                                 this.query(postGoal);
@@ -1093,6 +1404,7 @@ export class DMLRunner {
                                     providerOptions: this.options.providerOptions,
                                 },
                                 signal: runContext.signal,
+                                llmBackend: this.options.llmBackend,
                             });
                             this.postSampleTokenResult({ success: true, token });
                             if (usage) {
@@ -1126,6 +1438,8 @@ export class DMLRunner {
                                     providerOptions: this.options.providerOptions,
                                 },
                                 signal: runContext.signal,
+                                llmBackend: this.options.llmBackend,
+                                resolveMedia: (refs) => this.readMediaRefs(runContext.workspacePath, refs),
                             });
                             this.postLlmResult({ success: true, text });
                             if (usage) {
@@ -1143,6 +1457,49 @@ export class DMLRunner {
                         }
                         break;
                     }
+                    case 'request_judgment': {
+                        const parsed = this.parseJudgmentPayload(payload);
+                        const nestedStepId = `judge_${this.stepCounter++}`;
+                        const nestedIds = parsed.questions.map((question) => question.id);
+                        onToolEvent?.({
+                            type: 'task_activity',
+                            taskState: 'started',
+                            taskDescription: `judge[${parsed.requestedName}]: ${nestedIds.join(', ')}`,
+                            taskId: nestedStepId,
+                            judgeBackend: parsed.requestedName,
+                            judgeQuestionIds: nestedIds,
+                            judgeState: 'started',
+                        });
+                        const judgeResult = await this.completeJudgment(parsed, { signal: runContext.signal, judgeBackend: undefined });
+                        if (judgeResult.error) {
+                            this.postJudgmentResult({ success: false, error: judgeResult.error });
+                        }
+                        else {
+                            this.postJudgmentResult({ success: true, values: judgeResult.values ?? [] });
+                            if (judgeResult.usage) {
+                                onToolEvent?.({
+                                    type: 'usage',
+                                    usage: {
+                                        inputTokens: judgeResult.usage.inputTokens,
+                                        outputTokens: judgeResult.usage.outputTokens,
+                                        totalTokens: judgeResult.usage.totalTokens ??
+                                            judgeResult.usage.inputTokens + judgeResult.usage.outputTokens,
+                                    },
+                                    usageSource: 'judge',
+                                    usageModel: judgeResult.usageModel,
+                                });
+                            }
+                        }
+                        onToolEvent?.({
+                            type: 'task_activity',
+                            taskState: judgeResult.error ? 'failed' : 'completed',
+                            taskId: nestedStepId,
+                            judgeBackend: judgeResult.backendName,
+                            judgeQuestionIds: judgeResult.ids,
+                            judgeState: judgeResult.error ? 'failed' : 'completed',
+                        });
+                        break;
+                    }
                     case 'request_agent_loop': {
                         // Tool is calling task() or prompt() - run nested agent loop
                         const taskDescription = String(payload?.taskDescription ?? '');
@@ -1275,6 +1632,8 @@ export class DMLRunner {
                                 },
                                 streaming: this.options.streaming,
                                 debug: this.options.debug,
+                                llmBackend: this.options.llmBackend,
+                                resolveMedia: (refs) => this.readMediaRefs(runContext.workspacePath, refs),
                                 onOutput: (text) => {
                                     outputs.push(text);
                                     onOutput(text);
@@ -1282,26 +1641,26 @@ export class DMLRunner {
                                 onStream: (chunk, done) => {
                                     onToolEvent?.({ type: 'stream', content: chunk, done });
                                 },
+                                onReasoning: (chunk, done) => {
+                                    onToolEvent?.({ type: 'reasoning', content: chunk, done });
+                                },
                                 onUsage: (usage) => {
                                     onToolEvent?.({ type: 'usage', usage });
                                 },
+                                onModelCallPhase: (phase) => {
+                                    onToolEvent?.({ type: 'model_call', modelCallState: phase, modelId: this.options.model });
+                                },
                                 onToolCall: onToolCall ?? (() => { }), // Forward tool call events to parent
-                                onBeforeModelCall: async (messages, lastInputTokens) => this.applyCompactionBindings({
-                                    messages,
-                                    lastInputTokens,
-                                    scope: 'loop',
-                                    trigger: 'before_model_call',
-                                    options: { compaction: runContext.compaction },
-                                    executionContext: runContext,
-                                    registeredTools,
-                                    toolPolicy: runContext.toolPolicy ?? null,
-                                    emitEvent: onToolEvent,
-                                }),
+                                onBeforeModelCall: async (messages, lastInputTokens) => {
+                                    const hostCompacted = await this.applyHostCompaction(messages, lastInputTokens, onToolEvent);
+                                    return hostCompacted ?? messages;
+                                },
                                 onAskUser: async () => {
                                     // Nested agent loops don't support ask_user directly
                                     // If needed, the tool should use exec(ask_user, ...) instead
                                     return '';
                                 },
+                                onModelCall: runContext.onModelCall,
                                 signal: runContext.signal,
                             });
                             if (process.env.DEBUG_RUNNER) {
@@ -1363,116 +1722,17 @@ export class DMLRunner {
             }
         }
     }
-    async applyCompactionBindings(params) {
-        const resolved = resolveCompactionOptions(this.options.compaction, params.options.compaction);
-        const bindings = getCompactionBindings(resolved, params.scope, params.trigger);
-        if (bindings.length === 0) {
-            return params.messages;
-        }
-        let messages = params.messages;
-        for (const binding of bindings) {
-            const result = await executeCompactor({
-                binding,
-                messages,
-                knownInputTokens: params.lastInputTokens,
-                maxContextTokens: this.options.contextWindow,
-                emitEvent: params.emitEvent,
-                execute: (request) => this.runBoundCompactor({
-                    request,
-                    executionContext: params.executionContext,
-                    registeredTools: params.registeredTools,
-                    toolPolicy: params.toolPolicy,
-                }),
-            });
-            params.emitEvent?.(result.event);
-            if (result.usageByModel) {
-                for (const totals of Object.values(result.usageByModel)) {
-                    params.emitEvent?.({ type: 'usage', usage: {
-                            inputTokens: totals.inputTokens,
-                            outputTokens: totals.outputTokens,
-                            totalTokens: totals.totalTokens,
-                            cacheReadTokens: totals.cacheReadTokens || undefined,
-                            cacheWriteTokens: totals.cacheWriteTokens || undefined,
-                            reasoningTokens: totals.reasoningTokens || undefined,
-                        } });
-                }
-            }
-            messages = result.messages;
-        }
-        return messages;
-    }
-    async runBoundCompactor(params) {
-        const { binding, params: compactorParams } = params.request;
-        const code = await this.resolveCompactorSource(binding.compactor.source, binding.compactor.sourceType, params.executionContext.workspacePath);
-        const model = binding.compactor.model ?? this.options.model;
-        const provider = binding.compactor.provider
-            ?? (binding.compactor.model ? detectProvider(model) : this.options.provider);
-        const compactorRunner = new DMLRunner(this.swipl, {
-            ...this.options,
-            model,
-            provider,
-            streaming: false,
-            compaction: { enabled: false },
-        });
-        const { signal, dispose } = createChildAbortController(params.executionContext.signal, binding.compactor.timeoutMs);
-        try {
-            const tools = binding.compactor.inheritTools ? params.registeredTools : new Map();
-            let answer = '';
-            let errorContent = '';
-            const usageByModel = {};
-            for await (const event of compactorRunner.run(code, {
-                workspacePath: params.executionContext.workspacePath,
-                gasLimit: binding.compactor.gasLimit,
-                params: compactorParams,
-                initialMessages: params.request.messages,
-                tools,
-                toolPolicy: binding.compactor.toolPolicy ?? (binding.compactor.inheritTools ? params.toolPolicy : null) ?? null,
-                onInputRequired: async (prompt) => {
-                    throw new Error(`Compactor requested unexpected input: ${prompt}`);
-                },
-                signal,
-                compaction: { enabled: false },
-            })) {
-                if (event.type === 'answer' && event.content) {
-                    answer = event.content;
-                }
-                else if (event.type === 'error' && event.content) {
-                    errorContent = event.content;
-                }
-                else if (event.type === 'usage' && event.usage) {
-                    recordTokenUsage(usageByModel, this.options.model, event.usage);
-                }
-            }
-            return {
-                answer,
-                error: errorContent || undefined,
-                usageByModel: Object.keys(usageByModel).length > 0 ? usageByModel : undefined,
-            };
-        }
-        finally {
-            dispose();
-            await compactorRunner.dispose();
-        }
-    }
-    async resolveCompactorSource(source, sourceType, workspacePath) {
-        if (sourceType === 'inline') {
-            return source;
+    async applyHostCompaction(messages, lastInputTokens, emit) {
+        const host = this.options.compactMessages;
+        if (!host) {
+            return null;
         }
-        const basePath = workspacePath ?? process.cwd();
-        const candidatePath = path.isAbsolute(source) ? source : path.resolve(basePath, source);
-        try {
-            return await fs.readFile(candidatePath, 'utf8');
-        }
-        catch (error) {
-            if (sourceType === 'file') {
-                throw error;
-            }
-            return source;
+        const result = await host(messages, lastInputTokens);
+        if (result.event) {
+            emit?.(result.event);
         }
+        return result.messages;
     }
-    /**
-     * Extract memory from payload (now passed via state threading)
-     */
     extractMessagesFromValue(rawMessages) {
         const normalized = toJsValue(rawMessages);
         if (!Array.isArray(normalized)) {
@@ -1482,19 +1742,46 @@ export class DMLRunner {
             const msg = toJsValue(messageValue);
             const role = String(toJsValue(msg.role) ?? 'user');
             const content = String(toJsValue(msg.content) ?? '');
+            const media = this.extractMediaRefs(msg.media);
             if (role !== 'system' && role !== 'user' && role !== 'assistant') {
-                return { role: 'user', content };
+                return { role: 'user', content, media: media.length ? media : undefined };
             }
-            return { role: role, content };
+            return { role: role, content, media: media.length ? media : undefined };
         });
     }
+    /** Decode `media{path:..., mime:...}` dicts into reference-only refs. */
+    extractMediaRefs(raw) {
+        const value = toJsValue(raw);
+        if (!Array.isArray(value))
+            return [];
+        const refs = [];
+        for (const entry of value) {
+            const obj = toJsValue(entry);
+            const mediaPath = String(obj?.path ?? '');
+            const mimeType = String(obj?.mime ?? obj?.mimeType ?? '');
+            if (mediaPath && mimeType)
+                refs.push({ path: mediaPath, mimeType });
+        }
+        return refs;
+    }
+    /** Resolve a message's reference-only media to base64 bytes (workspace files). */
+    async readMediaRefs(workspacePath, refs) {
+        return resolveMediaRefs(workspacePath ?? process.cwd(), refs);
+    }
     extractMemoryFromPayload(rawPayload) {
         const rawMemory = toJsValue(rawPayload.memory);
         return this.extractMessagesFromValue(rawMemory);
     }
     serializeMemoryMessages(messages) {
         return messages
-            .map((message) => `message{role: ${message.role}, content: ${this.toPrologTerm(message.content)}}`)
+            .map((message) => {
+            const media = message.media && message.media.length > 0
+                ? `, media: [${message.media
+                    .map((ref) => `media{path: ${this.toPrologTerm(ref.path)}, mime: ${this.toPrologTerm(ref.mimeType)}}`)
+                    .join(', ')}]`
+                : '';
+            return `message{role: ${message.role}, content: ${this.toPrologTerm(message.content)}${media}}`;
+        })
             .join(', ');
     }
     /**
@@ -1562,6 +1849,30 @@ export class DMLRunner {
         const fullMemoryStr = this.serializeMemoryMessages(fullMemory ?? []);
         this.query(`deepclause_mi:post_tool_agent_result('${this.sessionId}', '${toolEngineId}', ${result.success}, vars{${varsStr}}, [${messagesStr}], [${fullMemoryStr}])`);
     }
+    /** SDK-internal ask_user tool used by exec(ask_user(...)) in DML. */
+    internalAskUserTool(options) {
+        return {
+            description: 'Ask the user for input or clarification',
+            parameters: {
+                type: 'object',
+                properties: {
+                    prompt: { type: 'string', description: 'The question or prompt to show the user' },
+                },
+                required: ['prompt'],
+            },
+            execute: async (args) => {
+                const prompt = String(args.prompt ?? args.arg1 ?? '');
+                if (!prompt) {
+                    return { error: 'No prompt provided to ask_user' };
+                }
+                const response = await options.onInputRequired(prompt);
+                if (response === undefined || response === null) {
+                    return { cancelled: true };
+                }
+                return { user_response: response };
+            },
+        };
+    }
     /**
      * Provide user input to waiting Prolog
      */
@@ -1569,6 +1880,10 @@ export class DMLRunner {
         const escaped = input.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
         this.query(`deepclause_mi:provide_input('${this.sessionId}', "${escaped}")`);
     }
+    /** Signal a waiting input/2 that no human is available. */
+    cancelInput() {
+        this.query(`deepclause_mi:provide_input_cancelled('${this.sessionId}')`);
+    }
     /**
      * Execute a Prolog query
      */
@@ -1587,14 +1902,17 @@ export class DMLRunner {
      * Cleanup resources
      */
     cleanup() {
-        if (this.engine) {
+        if (this.frames.size > 0) {
             try {
+                // destroy_engine/1 ends every frame registered for the session and
+                // retracts the session's dynamic state.
                 this.query(`deepclause_mi:destroy_engine('${this.sessionId}')`);
             }
             catch {
                 // Ignore cleanup errors
             }
-            this.engine = null;
+            this.frames.clear();
+            this.defaultFrameId = null;
         }
     }
     /**