deepclause-pi 0.3.0 → 0.5.0

package/src/index.ts

@@ -6,7 +6,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { DMLEvent } from "deepclause-sdk";
 import { Type } from "typebox";
 import { buildInitialMessages } from "./context.js";
-import { loadConfig, setModelToolEnabled, type ContextMode } from "./config.js";
+import { loadConfig, setJudgeConfig, setModelToolEnabled, type ContextMode, type DeepClauseConfig } from "./config.js";
 import { renderDml, renderSequence } from "./diagram/extract.js";
 import { polishDiagram, resolveGrade, type DiagramGrade } from "./diagram/grade.js";
 import { findChrome, validateMermaid, type MermaidView } from "./diagram/validate.js";
@@ -57,6 +57,7 @@ export interface ParsedRun {
   contextMode?: ContextMode;
   verbose: boolean;
   debug: boolean;
+  judge?: string;
 }
 
 interface ParsedPlan {
@@ -125,11 +126,13 @@ export function parseRun(input: string): ParsedRun {
   let contextMode: ContextMode | undefined;
   let verbose = false;
   let debug = false;
+  let judge: string | undefined;
   const args: string[] = [];
 
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index]!;
     const contextValue = token.startsWith("--context=") ? token.slice("--context=".length) : undefined;
+    const judgeValue = token.startsWith("--judge=") ? token.slice("--judge=".length) : undefined;
     if (token === "--verbose" || token === "-v") {
       verbose = true;
     } else if (token === "--debug" || token === "-d") {
@@ -146,11 +149,18 @@ export function parseRun(input: string): ParsedRun {
         throw new Error("--context must be turn, branch, or isolated");
       }
       contextMode = value;
+    } else if (judgeValue !== undefined) {
+      if (!judgeValue.trim()) throw new Error("--judge requires a non-empty backend name");
+      judge = judgeValue.trim();
+    } else if (token === "--judge") {
+      const value = tokens[++index];
+      if (!value || !value.trim()) throw new Error("--judge requires a non-empty backend name");
+      judge = value.trim();
     } else {
       args.push(token);
     }
   }
-  return { target, args, contextMode, verbose, debug };
+  return { target, args, contextMode, verbose, debug, judge };
 }
 
 export function parsePlan(input: string): ParsedPlan {
@@ -288,6 +298,18 @@ function modelLabel(ctx: ExtensionCommandContext): string {
   return ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "none selected";
 }
 
+function judgeBackendsEnabled(config: DeepClauseConfig): string {
+  return config.judgment.jev.enabled ? ", jev" : "";
+}
+
+function jevStatus(config: DeepClauseConfig): string {
+  const jev = config.judgment.jev;
+  if (!jev.enabled) return "disabled";
+  return process.env[jev.apiKeyEnv]
+    ? `enabled (${jev.model})`
+    : `enabled but ${jev.apiKeyEnv} is not set`;
+}
+
 async function bundledViewerTemplate(): Promise<string> {
   return readFile(fileURLToPath(new URL("./assets/viewer.template.html", import.meta.url)), "utf8");
 }
@@ -300,6 +322,24 @@ function publishResult(pi: ExtensionAPI, content: string, details: Record<string
   pi.sendMessage({ customType: "deepclause-result", content, display: true, details });
 }
 
+/**
+ * Ask the user a DeepClause question.
+ *
+ * Pi's interactive text-input dialog renders only its title: the placeholder
+ * argument is ignored by `ExtensionInputComponent`. Passing the question as the
+ * placeholder (as the extension used to) made it invisible, so put the whole
+ * question in the title and label which run is asking.
+ */
+export function requestDeepClauseInput(
+  ctx: Pick<ExtensionContext, "ui">,
+  label: string,
+  prompt: string,
+  signal: AbortSignal,
+): Promise<string | undefined> {
+  const heading = label ? `DeepClause input — ${label}` : "DeepClause input";
+  return ctx.ui.input(`${heading}\n\n${prompt}`, undefined, { signal });
+}
+
 export default function deepClauseExtension(pi: ExtensionAPI) {
   let activeController: AbortController | undefined;
   let activeDescription: string | undefined;
@@ -310,6 +350,27 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
   let planningTransaction: PlanningTransaction | undefined;
   let pendingAgentStep: PendingAgentStep | undefined;
 
+  /**
+   * Claim the single DeepClause execution slot synchronously, before any await.
+   * Without this, parallel `dc_run` calls all pass the `activeController` check
+   * while the first one is still awaiting its setup, then run concurrently and
+   * fight over the one-slot pi input dialog (leaving earlier runs hung).
+   */
+  const claimExecution = (description: string): AbortController | undefined => {
+    if (activeController) return undefined;
+    const controller = new AbortController();
+    activeController = controller;
+    activeDescription = description;
+    return controller;
+  };
+
+  const releaseExecution = (controller: AbortController): void => {
+    if (activeController === controller) {
+      activeController = undefined;
+      activeDescription = undefined;
+    }
+  };
+
   const setPlanCommitActive = (enabled: boolean) => {
     if (enabled && !planCommitRegistered) {
       pi.registerTool({
@@ -506,6 +567,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
         promptGuidelines: [
           "Use dc_run only for existing DML programs when their deterministic logic, constraints, or specialized orchestration is useful; do not use dc_run to compile natural language or create a skill.",
           "Do not call dc_run while another DeepClause execution is active, and do not claim success unless dc_run returns an answer without errors.",
+          "If dc_run reports execution_already_active, wait for the active run to finish and then retry this skill instead of reporting failure.",
         ],
         parameters: Type.Object({
           skill: Type.String({ description: "Skill name such as example, or a DML path relative to .pi/deepclause/." }),
@@ -515,46 +577,45 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
           })),
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
-          if (activeController) {
+          const controller = claimExecution("dc_run");
+          if (!controller) {
             return {
-              content: [{ type: "text", text: "DeepClause execution rejected: another execution is already active." }],
+              content: [{ type: "text", text: "DeepClause execution rejected: another execution is active. Wait for it to finish, then call dc_run again for this skill." }],
               details: { success: false, error: "execution_already_active" },
             };
           }
-
-          const paths = await initializeWorkspace(ctx.cwd);
-          const config = await loadConfig(paths.config);
-          if (!config.modelToolEnabled || !pi.getActiveTools().includes(DC_RUN_TOOL)) {
-            return {
-              content: [{ type: "text", text: "The dc_run tool is disabled. The user can enable it with /dc-tool enable." }],
-              details: { success: false, error: "tool_disabled" },
-            };
-          }
-
-          const mode = params.context ?? config.contextMode;
-          const filePath = await resolveDmlPath(paths, params.skill);
-          if (await isContextualPlan(filePath)) {
-            return {
-              content: [{ type: "text", text: "Contextual DML plans must be started by the user with /dc-run; they cannot start a nested pi agent turn from dc_run." }],
-              details: { success: false, error: "interactive_plan_requires_user_run" },
-            };
-          }
-          const skillName = path.relative(paths.root, filePath);
-          const initialMessages = buildInitialMessages(
-            ctx.sessionManager.getBranch(),
-            mode,
-            config.branchMessageLimit,
-          );
-          const controller = new AbortController();
           const cancel = () => controller.abort(signal?.reason ?? new Error("dc_run cancelled"));
           if (signal?.aborted) cancel();
           else signal?.addEventListener("abort", cancel, { once: true });
-          activeController = controller;
-          activeDescription = `model tool running ${skillName}`;
-          const startedAt = Date.now();
-          const progress: string[] = [];
 
           try {
+            const paths = await initializeWorkspace(ctx.cwd);
+            const config = await loadConfig(paths.config);
+            if (!config.modelToolEnabled || !pi.getActiveTools().includes(DC_RUN_TOOL)) {
+              return {
+                content: [{ type: "text", text: "The dc_run tool is disabled. The user can enable it with /dc-tool enable." }],
+                details: { success: false, error: "tool_disabled" },
+              };
+            }
+
+            const mode = params.context ?? config.contextMode;
+            const filePath = await resolveDmlPath(paths, params.skill);
+            if (await isContextualPlan(filePath)) {
+              return {
+                content: [{ type: "text", text: "Contextual DML plans must be started by the user with /dc-run; they cannot start a nested pi agent turn from dc_run." }],
+                details: { success: false, error: "interactive_plan_requires_user_run" },
+              };
+            }
+            const skillName = path.relative(paths.root, filePath);
+            activeDescription = `model tool running ${skillName}`;
+            const initialMessages = buildInitialMessages(
+              ctx.sessionManager.getBranch(),
+              mode,
+              config.branchMessageLimit,
+            );
+            const startedAt = Date.now();
+            const progress: string[] = [];
+
             const result = await executeDml(
               filePath,
               params.args ?? [],
@@ -578,7 +639,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
                 onDiagnostic: () => {},
                 onInput: async (prompt, inputSignal) => {
                   if (!ctx.hasUI) throw new Error("dc_run cannot request user input without interactive UI");
-                  const answer = await ctx.ui.input("DeepClause input", prompt, { signal: inputSignal });
+                  const answer = await requestDeepClauseInput(ctx, skillName, prompt, inputSignal);
                   if (answer === undefined) throw new Error("Input cancelled");
                   return answer;
                 },
@@ -604,12 +665,11 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
             const message = error instanceof Error ? error.message : String(error);
             return {
               content: [{ type: "text", text: `DeepClause execution failed: ${message}` }],
-              details: { success: false, skill: skillName, contextMode: mode, error: message },
+              details: { success: false, error: message },
             };
           } finally {
             signal?.removeEventListener("abort", cancel);
-            activeController = undefined;
-            activeDescription = undefined;
+            releaseExecution(controller);
           }
         },
       });
@@ -630,11 +690,11 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
       pi.registerTool({
         name: DC_DIAGRAM_TOOL,
         label: "Create DeepClause Diagram",
-        description: "Create a presentation-grade or specification-grade Mermaid diagram from any .dml file, write a self-contained offline viewer under .pi/deepclause/diagrams/, and open it.",
+        description: "Create a presentation-grade or specification-grade Mermaid diagram from any .dml file, write a self-contained offline viewer under .pi/deepclause/diagrams/, and open it. The specification grade preserves the core decision logic and rule facts.",
         promptSnippet: "Create a presentation- or specification-grade diagram from a DML file",
         promptGuidelines: [
           "Use dc_diagram whenever the user asks for a diagram, flowchart, or visual of a .dml file; pass the exact path the user named.",
-          "Choose grade=presentation for slides and overviews and grade=specification for engineering detail; use grade=both only when the user asks for both.",
+          "Choose grade=presentation for slides and overviews and grade=specification for engineering detail (decision predicates, thresholds, rule facts); use grade=both only when the user asks for both.",
           "Do not hand-write Mermaid or run diagram tools yourself; call dc_diagram and report the viewer result.",
         ],
         parameters: Type.Object({
@@ -643,55 +703,51 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
           view: Type.Optional(StringEnum(["flow", "sequence"] as const, { description: "Base layout used to seed the grade; default flow." })),
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
-          if (activeController) {
+          const controller = claimExecution("dc_diagram");
+          if (!controller) {
             return {
               content: [{ type: "text", text: "Another DeepClause operation is already active; wait for it to finish." }],
               details: { success: false, error: "execution_already_active" },
             };
           }
-
-          const requested = resolveGrade(String(params.grade ?? "")) ?? "presentation";
-          const grades: DiagramGrade[] = requested === "both" ? ["presentation", "specification"] : [requested];
-          const view: MermaidView = params.view === "sequence" ? "sequence" : "flow";
-
-          let sourcePath: string;
-          try {
-            sourcePath = await resolveDiagramSource(ctx.cwd, params.dml);
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: "text", text: `dc_diagram failed: ${message}` }], details: { success: false, error: message } };
-          }
-          if (!ctx.model) {
-            return {
-              content: [{ type: "text", text: "dc_diagram requires an active pi model. Select one and try again." }],
-              details: { success: false, error: "no_model" },
-            };
-          }
-
-          const config = await loadConfig(getPaths(ctx.cwd).config);
-          const source = await readFile(sourcePath, "utf8");
-          const display = displayPath(ctx.cwd, sourcePath);
-          const seed = view === "sequence"
-            ? renderSequence(display, source)
-            : renderDml(display, source, { hideOutput: true });
-          const targets = await collectDiagramTargets(ctx.cwd, [sourcePath]);
-          const name = diagramNameFor(sourcePath, targets, ctx.cwd);
-          const { diagrams, vendor } = await ensureDiagramDir(ctx.cwd, viewerVendorAssetPath());
-          const templateText = await bundledViewerTemplate();
-
-          const controller = new AbortController();
           const cancel = () => controller.abort(signal?.reason ?? new Error("dc_diagram cancelled"));
           if (signal?.aborted) cancel();
           else signal?.addEventListener("abort", cancel, { once: true });
-          activeController = controller;
-          activeDescription = `diagram ${name} (${grades.join("+")})`;
-
-          const run = (command: string, args: string[], options?: { timeout?: number }) => pi.exec(command, args, options);
-          let chrome: string | undefined;
-          let chromeResolved = false;
 
           try {
+            const requested = resolveGrade(String(params.grade ?? "")) ?? "presentation";
+            const grades: DiagramGrade[] = requested === "both" ? ["presentation", "specification"] : [requested];
+            const view: MermaidView = params.view === "sequence" ? "sequence" : "flow";
+
+            const sourcePath = await resolveDiagramSource(ctx.cwd, params.dml);
+            if (!ctx.model) {
+              return {
+                content: [{ type: "text", text: "dc_diagram requires an active pi model. Select one and try again." }],
+                details: { success: false, error: "no_model" },
+              };
+            }
+
+            const config = await loadConfig(getPaths(ctx.cwd).config);
+            const source = await readFile(sourcePath, "utf8");
+            const display = displayPath(ctx.cwd, sourcePath);
+            const targets = await collectDiagramTargets(ctx.cwd, [sourcePath]);
+            const name = diagramNameFor(sourcePath, targets, ctx.cwd);
+            const { diagrams, vendor } = await ensureDiagramDir(ctx.cwd, viewerVendorAssetPath());
+            const templateText = await bundledViewerTemplate();
+
+            activeDescription = `diagram ${name} (${grades.join("+")})`;
+
+            const run = (command: string, args: string[], options?: { timeout?: number }) => pi.exec(command, args, options);
+            let chrome: string | undefined;
+            let chromeResolved = false;
+
             for (const grade of grades) {
+              // The specification seed carries the core decision logic and rule
+              // facts; the presentation seed stays small so the model can keep
+              // it to a general-audience overview.
+              const seed = view === "sequence"
+                ? renderSequence(display, source)
+                : renderDml(display, source, { hideOutput: true, includeLogic: grade === "specification" });
               const result = await polishDiagram({
                 grade,
                 view,
@@ -736,8 +792,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
             return { content: [{ type: "text", text: `dc_diagram failed: ${message}` }], details: { success: false, error: message } };
           } finally {
             signal?.removeEventListener("abort", cancel);
-            activeController = undefined;
-            activeDescription = undefined;
+            releaseExecution(controller);
           }
         },
       });
@@ -789,7 +844,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
             const viewer = displayPath(ctx.cwd, build.viewerPath);
             return {
               content: [{ type: "text", text: `Created spec graph (${view}). Viewer: ${viewer}${opened ? " (opened in your browser)" : ""}` }],
-              details: { success: true, view, viewer, opened },
+              details: { success: true, view, viewer, viewerPath: build.viewerPath, opened },
             };
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -811,13 +866,12 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
     args: string[] = [],
     options: { verifyCommands?: string[]; piAgentStep?: boolean; changeJsonPath?: string } = {},
   ): Promise<string> => {
-    const paths = await initializeWorkspace(ctx.cwd);
-    const config = await loadConfig(paths.config);
-    const filePath = await resolveDmlPath(paths, skill);
-    const controller = new AbortController();
-    activeController = controller;
-    activeDescription = `running ${skill}`;
+    const controller = claimExecution(`running ${skill}`);
+    if (!controller) throw new Error("Another DeepClause execution is already active");
     try {
+      const paths = await initializeWorkspace(ctx.cwd);
+      const config = await loadConfig(paths.config);
+      const filePath = await resolveDmlPath(paths, skill);
       const result = await executeDml(
         filePath,
         args,
@@ -837,8 +891,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
       if (result.errors.length) throw new Error(result.errors.join("\n"));
       return result.answer ?? "(no answer)";
     } finally {
-      activeController = undefined;
-      activeDescription = undefined;
+      releaseExecution(controller);
     }
   };
 
@@ -926,6 +979,8 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
         `Skills: ${path.relative(ctx.cwd, paths.skills)}`,
         `Plans: ${path.relative(ctx.cwd, paths.plans)}`,
         `Context: ${config.contextMode} (verbose default: ${config.verbose})`,
+        `Judgment: ${config.judgment.default} (backends: llm${judgeBackendsEnabled(config)})`,
+        `Jev: ${jevStatus(config)}`,
         `Model tool (${DC_RUN_TOOL}): ${config.modelToolEnabled && pi.getActiveTools().includes(DC_RUN_TOOL) ? "enabled" : "disabled"}`,
         `Model tool (${DC_DIAGRAM_TOOL}): ${pi.getActiveTools().includes(DC_DIAGRAM_TOOL) ? "enabled" : "disabled"}`,
         "Ask pi for a presentation-grade or specification-grade diagram of any .dml file;",
@@ -936,10 +991,13 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
         "  /dc-check <change|spec>            validate specs and deltas deterministically",
         "  /dc-archive <change>              merge a change delta into specs/ and archive it",
         "  /dc-apply <change> [--abort]       execute tasks.dml; --abort discards an interrupted apply",
-        "  /dc-run <skill|path> [args] [--context=turn|branch|isolated]",
+        "  /dc-run <skill|path> [args] [--context=turn|branch|isolated] [--judge=llm|jev]",
         "  /dc-run <skill|path> --verbose   show lifecycle events",
         "  /dc-run <skill|path> --debug     show full event payloads and SDK diagnostics",
         "  /dc-tool enable|disable|status   control the model-callable dc_run tool",
+        "  /dc-judge [enable|disable|status]  select the judgment backend (llm|jev)",
+        "  /dc-judge default llm|jev        set the default judgment backend",
+        "  /dc-judge model <name> | key-env <ENV_VAR>",
         "  /dc-cancel",
       ].join("\n");
       ctx.ui.notify(message, "info");
@@ -1032,6 +1090,78 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerCommand("dc-judge", {
+    description: "Enable, disable, or select the semantic judgment backend (llm|jev)",
+    handler: async (rawArgs, ctx) => {
+      const tokens = rawArgs.trim().split(/\s+/).filter(Boolean);
+      const action = (tokens[0] ?? "status").toLowerCase();
+      const paths = await initializeWorkspace(ctx.cwd);
+
+      const describe = (config: DeepClauseConfig): string => {
+        const jev = config.judgment.jev;
+        const keyPresent = Boolean(process.env[jev.apiKeyEnv]);
+        return [
+          `judgment backend: ${config.judgment.default}`,
+          `registered backends: llm${jev.enabled ? ", jev" : ""}`,
+          `jev: ${jev.enabled ? "enabled" : "disabled"} | model=${jev.model} | ${jev.apiKeyEnv}=${keyPresent ? "set" : "not set"}`,
+        ].join("\n");
+      };
+
+      try {
+        if (action === "status") {
+          ctx.ui.notify(describe(await loadConfig(paths.config)), "info");
+          return;
+        }
+        if (action === "enable" || action === "on" || action === "disable" || action === "off") {
+          const enabled = action === "enable" || action === "on";
+          const config = await setJudgeConfig(paths.config, { jev: { enabled } });
+          const jev = config.judgment.jev;
+          const note = enabled && !process.env[jev.apiKeyEnv]
+            ? `\n${jev.apiKeyEnv} is not set; export it before using --judge=jev.`
+            : "";
+          ctx.ui.notify(`Jev backend ${enabled ? "enabled" : "disabled"} for this workspace.${note}`, enabled ? "warning" : "info");
+          return;
+        }
+        if (action === "default") {
+          const name = tokens[1];
+          if (name !== "llm" && name !== "jev") {
+            ctx.ui.notify("Usage: /dc-judge default llm|jev", "warning");
+            return;
+          }
+          await setJudgeConfig(paths.config, { default: name });
+          ctx.ui.notify(`Default judgment backend set to '${name}'`, "info");
+          return;
+        }
+        if (action === "model") {
+          const model = tokens[1];
+          if (!model) {
+            ctx.ui.notify("Usage: /dc-judge model <name>", "warning");
+            return;
+          }
+          await setJudgeConfig(paths.config, { jev: { model } });
+          ctx.ui.notify(`Jev model set to '${model}'`, "info");
+          return;
+        }
+        if (action === "key-env") {
+          const envName = tokens[1];
+          if (!envName) {
+            ctx.ui.notify("Usage: /dc-judge key-env <ENV_VAR>", "warning");
+            return;
+          }
+          await setJudgeConfig(paths.config, { jev: { apiKeyEnv: envName } });
+          ctx.ui.notify(`Jev API key environment variable set to '${envName}'`, "info");
+          return;
+        }
+        ctx.ui.notify(
+          "Usage: /dc-judge [enable|disable|status|default llm|jev|model <name>|key-env <ENV_VAR>]",
+          "warning",
+        );
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      }
+    },
+  });
+
   pi.registerCommand("dc-list", {
     description: "List DeepClause DML skills and generated plans",
     handler: async (_args, ctx) => {
@@ -1188,8 +1318,8 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
   pi.registerCommand("dc-run", {
     description: "Run a DML skill with pi's active model",
     handler: async (rawArgs, ctx) => {
-
-      if (activeController) {
+      const controller = claimExecution("dc-run");
+      if (!controller) {
         ctx.ui.notify("A DeepClause execution is already active", "warning");
         return;
       }
@@ -1230,8 +1360,6 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
           mode,
           config.branchMessageLimit,
         );
-        const controller = new AbortController();
-        activeController = controller;
         const outputLines: string[] = [];
         const recentEvents: string[] = [];
         const events: Array<Record<string, unknown>> = [];
@@ -1302,7 +1430,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
             filePath,
             parsed.args,
             initialMessages,
-            { ...config, verbose: config.verbose || parsed.debug },
+            { ...config, verbose: config.verbose || parsed.debug, judgeBackend: parsed.judge },
             pi,
             ctx,
             controller,
@@ -1310,7 +1438,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
               onEvent,
               onDiagnostic,
               onInput: async (prompt, signal) => {
-                const answer = await ctx.ui.input("DeepClause input", prompt, { signal });
+                const answer = await requestDeepClauseInput(ctx, skillName, prompt, signal);
                 if (answer === undefined) throw new Error("Input cancelled");
                 return answer;
               },
@@ -1338,8 +1466,7 @@ export default function deepClauseExtension(pi: ExtensionAPI) {
         publishResult(pi, `DeepClause execution failed: ${message}`, { error: message });
         ctx.ui.notify(message, activeController?.signal.aborted ? "warning" : "error");
       } finally {
-        activeController = undefined;
-        activeDescription = undefined;
+        releaseExecution(controller);
         ctx.ui.setStatus(STATUS_KEY, undefined);
         ctx.ui.setWidget(WIDGET_KEY, undefined);
       }

package/src/runtime.ts

@@ -1,8 +1,9 @@
 import { realpath, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { createDeepClause } from "deepclause-sdk";
+import { createDeepClause, createJevJudgeBackend, createLLMJudgeBackend } from "deepclause-sdk";
 import type {
   DMLEvent,
+  JudgeBackend,
   LLMBackend,
   LLMBackendMessage,
   LLMUsage,
@@ -327,7 +328,7 @@ export async function executeDml(
   filePath: string,
   args: string[],
   initialMessages: MemoryMessage[],
-  config: DeepClauseConfig,
+  config: DeepClauseConfig & { judgeBackend?: string },
   pi: ExtensionAPI,
   ctx: ExtensionContext,
   controller: AbortController,
@@ -339,12 +340,38 @@ export async function executeDml(
   const model = ctx.model;
   if (!model) throw new Error("Select a pi model before running DeepClause");
   const backend = createPiBackend(ctx, config.maxTokens, callbacks.onDiagnostic ?? (() => {}));
+
+  // Judgment backends. `llm` reuses pi's active model and credentials; `jev`
+  // is opt-in and only registered when enabled and its key is present.
+  const judgeBackends: Record<string, JudgeBackend> = {
+    llm: createLLMJudgeBackend({ llmBackend: backend, model: model.id }),
+  };
+  const jev = config.judgment.jev;
+  if (jev.enabled) {
+    const apiKey = process.env[jev.apiKeyEnv];
+    if (apiKey) {
+      judgeBackends.jev = createJevJudgeBackend({ apiKey, model: jev.model });
+    } else {
+      callbacks.onDiagnostic?.(
+        `judgment backend 'jev' is enabled but ${jev.apiKeyEnv} is not set; falling back to 'llm'`,
+      );
+    }
+  }
+  const requestedJudge = config.judgeBackend ?? config.judgment.default;
+  if (!judgeBackends[requestedJudge]) {
+    throw new Error(
+      `Judgment backend '${requestedJudge}' is not available. Enable it in .pi/deepclause/config.json or use --judge=llm.`,
+    );
+  }
+
   const sdk = await createDeepClause({
     model: model.id,
     maxTokens: config.maxTokens,
     streaming: true,
     debug: config.verbose,
     llmBackend: backend,
+    judgeBackends,
+    defaultJudge: requestedJudge,
   });
   registerPiRuntimeTools(
     sdk,
@@ -458,6 +485,7 @@ export async function executeDml(
       gasLimit: config.gasLimit,
       signal: controller.signal,
       initialMessages,
+      judgeBackend: config.judgeBackend,
       onUserInput: (prompt) => callbacks.onInput(prompt, controller.signal),
     })) {
       callbacks.onEvent(event);