pi-ultracode 0.10.2 → 0.10.4

package/package.json

@@ -1,29 +1,28 @@
 {
   "name": "pi-ultracode",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Adaptive semantic-depth workflow orchestration for Pi, with focused, standard, and deep modes, isolated subagents, worktree delivery, structured output, and durable resume.",
-  "type": "module",
   "keywords": [
-    "pi-package",
+    "agents",
+    "orchestration",
     "pi",
     "pi-coding-agent",
+    "pi-package",
+    "subagents",
     "ultracode",
     "workflow",
-    "workflows",
-    "agents",
-    "subagents",
-    "orchestration"
+    "workflows"
   ],
-  "author": "pi-ultracode",
+  "homepage": "https://github.com/ekil1100/pi-ultracode#readme",
+  "bugs": {
+    "url": "https://github.com/ekil1100/pi-ultracode/issues"
+  },
   "license": "MIT",
+  "author": "pi-ultracode",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ekil1100/pi-ultracode.git"
   },
-  "homepage": "https://github.com/ekil1100/pi-ultracode#readme",
-  "bugs": {
-    "url": "https://github.com/ekil1100/pi-ultracode/issues"
-  },
   "files": [
     "extensions/",
     "src/",
@@ -31,35 +30,36 @@
     "examples/",
     "README.md"
   ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "pi": {
-    "extensions": [
-      "./extensions/ultracode.ts"
-    ]
-  },
+  "type": "module",
   "exports": {
     "./workflow": {
       "types": "./types/workflow.d.ts"
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
-    "test": "node --experimental-strip-types --test test/*.test.ts",
-    "typecheck": "tsc --noEmit"
+    "test": "vp test run",
+    "check": "vp check",
+    "typecheck": "vp exec tsc --noEmit"
   },
   "dependencies": {
-    "acorn": "^8.11.0"
+    "acorn": "^8.11.0",
+    "effect": "^4.0.0",
+    "js-beautify": "^2.0.3"
   },
   "devDependencies": {
     "@earendil-works/pi-agent-core": "^0.99.1",
     "@earendil-works/pi-ai": "^0.99.1",
     "@earendil-works/pi-coding-agent": "^0.99.1",
     "@earendil-works/pi-tui": "^0.99.1",
+    "@types/js-beautify": "^1.14.3",
     "@types/node": "^24.12.4",
     "typebox": "1.3.7",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite-plus": "1.0.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": ">=0.99.1",
@@ -84,5 +84,21 @@
     "typebox": {
       "optional": true
     }
+  },
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "version": "11.19.0",
+      "onFail": "download"
+    }
+  },
+  "packageManager": "npm@11.19.0",
+  "pi": {
+    "extensions": [
+      "./extensions/ultracode.ts"
+    ]
   }
 }

package/src/commands.ts

@@ -2,14 +2,22 @@
  * Slash commands: `/ultracode` (mode toggle) and `/workflows` (run manager).
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { ACTIVE_ULTRACODE_MODES, MODE_DESCRIPTIONS, isActiveUltracodeMode, isUltracodeModeName } from "./depth.ts";
+import { Effect, Result } from "effect";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  ACTIVE_ULTRACODE_MODES,
+  MODE_DESCRIPTIONS,
+  isActiveUltracodeMode,
+  isUltracodeModeName,
+} from "./depth.ts";
 import type { UltracodeMode } from "./mode.ts";
 import type { UltracodePreferenceStore } from "./preferences.ts";
 import type { WorkflowRegistry } from "./workflow/registry.ts";
 import { workflowRunsDir } from "./workflow/tool.ts";
 import { openWorkflowOverlay } from "./workflow/workflow-overlay.ts";
 
+const attempt = <A>(thunk: () => A) => Effect.try({ try: thunk, catch: (error) => error });
+
 export function registerCommands(
   pi: ExtensionAPI,
   mode: UltracodeMode,
@@ -17,117 +25,157 @@ export function registerCommands(
   preferences: UltracodePreferenceStore,
 ): void {
   pi.registerCommand("ultracode", {
-    description: "Analysis depth: auto routing, focused local checks, standard targeted verification, deep invariant/counterexample checks; off|status|default on|off",
+    description:
+      "Analysis depth: auto routing, focused local checks, standard targeted verification, deep invariant/counterexample checks; off|status|default on|off",
     getArgumentCompletions(prefix: string) {
       return [...ACTIVE_ULTRACODE_MODES, "off", "status", "default", "default on", "default off"]
         .filter((value) => value.startsWith(prefix))
-        .map((value) => ({ value, label: value, description: isUltracodeModeName(value) ? MODE_DESCRIPTIONS[value] : undefined }));
+        .map((value) => ({
+          value,
+          label: value,
+          description: isUltracodeModeName(value) ? MODE_DESCRIPTIONS[value] : undefined,
+        }));
     },
-    handler: async (args: string, ctx) => {
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      const sub = (parts[0] ?? "").toLowerCase();
+    handler: (args: string, ctx) =>
+      Effect.runPromise(
+        attempt(() => {
+          const parts = args.trim().split(/\s+/).filter(Boolean);
+          const sub = (parts[0] ?? "").toLowerCase();
 
-      // Bare `/ultracode` enables auto from off and disables any active mode.
-      if (sub === "") {
-        const nowOn = mode.toggle(pi);
-        ctx.ui.notify(
-          nowOn
-            ? `Ultracode auto — ${MODE_DESCRIPTIONS.auto}`
-            : "Ultracode off — workflow tool disabled; parent effort unchanged.",
-          "info",
-        );
-        ctx.ui.setStatus(
-          "ultracode",
-          nowOn ? mode.statusLine((label) => ctx.ui.theme.fg("accent", label)) : undefined,
-        );
-        return;
-      }
+          // Bare `/ultracode` enables auto from off and disables any active mode.
+          if (sub === "") {
+            const nowOn = mode.toggle(pi);
+            ctx.ui.notify(
+              nowOn
+                ? `Ultracode auto — ${MODE_DESCRIPTIONS.auto}`
+                : "Ultracode off — workflow tool disabled; parent effort unchanged.",
+              "info",
+            );
+            ctx.ui.setStatus(
+              "ultracode",
+              nowOn ? mode.statusLine((text, color) => ctx.ui.theme.fg(color, text)) : undefined,
+            );
+            return;
+          }
 
-      if (sub === "default") {
-        const value = parts[1]?.toLowerCase();
-        if (parts.length > 2 || (value !== undefined && value !== "on" && value !== "off")) {
-          ctx.ui.notify("Usage: /ultracode default [on|off]", "error");
-          return;
-        }
-        try {
-          if (value !== undefined) preferences.setDefaultEnabled(value === "on");
-          const enabled = preferences.getDefaultEnabled();
-          if (value === "on") {
-            if (!mode.isEnabled()) mode.enable(pi, "auto");
-            ctx.ui.setStatus("ultracode", mode.statusLine((label) => ctx.ui.theme.fg("accent", label)));
+          if (sub === "default") {
+            const value = parts[1]?.toLowerCase();
+            if (parts.length > 2 || (value !== undefined && value !== "on" && value !== "off")) {
+              ctx.ui.notify("Usage: /ultracode default [on|off]", "error");
+              return;
+            }
+            Result.try({
+              try: () => {
+                if (value !== undefined) preferences.setDefaultEnabled(value === "on");
+                const enabled = preferences.getDefaultEnabled();
+                if (value === "on") {
+                  if (!mode.isEnabled()) mode.enable(pi, "auto");
+                  ctx.ui.setStatus(
+                    "ultracode",
+                    mode.statusLine((text, color) => ctx.ui.theme.fg(color, text)),
+                  );
+                }
+                const sessionStatus =
+                  value === "on"
+                    ? `current session: ${mode.getMode()}`
+                    : "current session unchanged";
+                ctx.ui.notify(
+                  `Ultracode default ${enabled ? "on (auto)" : "off"} — global startup preference; ${sessionStatus}.`,
+                  "info",
+                );
+              },
+              catch: (error) => error,
+            }).pipe(
+              Result.getOrElse((error) => {
+                ctx.ui.notify(
+                  `Failed to ${value === undefined ? "read" : "save"} Ultracode default: ${String(error)}`,
+                  "error",
+                );
+              }),
+            );
+            return;
           }
-          const sessionStatus = value === "on" ? `current session: ${mode.getMode()}` : "current session unchanged";
-          ctx.ui.notify(
-            `Ultracode default ${enabled ? "on (auto)" : "off"} — global startup preference; ${sessionStatus}.`,
-            "info",
-          );
-        } catch (error) {
-          ctx.ui.notify(`Failed to ${value === undefined ? "read" : "save"} Ultracode default: ${String(error)}`, "error");
-        }
-        return;
-      }
 
-      if (parts.length > 1) {
-        ctx.ui.notify(ultracodeUsage(), "error");
-        return;
-      }
+          if (parts.length > 1) {
+            ctx.ui.notify(ultracodeUsage(), "error");
+            return;
+          }
 
-      if (sub === "status") {
-        ctx.ui.notify(`${mode.statusLine()} — ${MODE_DESCRIPTIONS[mode.getMode()]} Depth is independent of model effort.`, "info");
-        return;
-      }
+          if (sub === "status") {
+            ctx.ui.notify(
+              `${mode.statusLine()} — ${MODE_DESCRIPTIONS[mode.getMode()]} Depth is independent of model effort.`,
+              "info",
+            );
+            return;
+          }
 
-      if (sub === "off") {
-        mode.disable(pi);
-        ctx.ui.notify("Ultracode off — workflow tool disabled; parent effort unchanged.", "info");
-        ctx.ui.setStatus("ultracode", undefined);
-        return;
-      }
+          if (sub === "off") {
+            mode.disable(pi);
+            ctx.ui.notify(
+              "Ultracode off — workflow tool disabled; parent effort unchanged.",
+              "info",
+            );
+            ctx.ui.setStatus("ultracode", undefined);
+            return;
+          }
 
-      if (!isActiveUltracodeMode(sub)) {
-        ctx.ui.notify(ultracodeUsage(), "error");
-        return;
-      }
+          if (!isActiveUltracodeMode(sub)) {
+            ctx.ui.notify(ultracodeUsage(), "error");
+            return;
+          }
 
-      mode.enable(pi, sub);
-      ctx.ui.notify(`Ultracode ${sub} — ${MODE_DESCRIPTIONS[sub]}`, "info");
-      ctx.ui.setStatus(
-        "ultracode",
-        mode.statusLine((label) => ctx.ui.theme.fg("accent", label)),
-      );
-    },
+          mode.enable(pi, sub);
+          ctx.ui.notify(`Ultracode ${sub} — ${MODE_DESCRIPTIONS[sub]}`, "info");
+          ctx.ui.setStatus(
+            "ultracode",
+            mode.statusLine((text, color) => ctx.ui.theme.fg(color, text)),
+          );
+        }),
+      ),
   });
 
-  const openWorkflows = async (ctx: any, runId?: string) => {
-    registry.restoreRuns(workflowRunsDir(ctx));
-    await openWorkflowOverlay(ctx, registry, runId);
-  };
+  const openWorkflows = (ctx: ExtensionContext, runId?: string) =>
+    attempt(() => registry.restoreRuns(workflowRunsDir(ctx))).pipe(
+      Effect.andThen(
+        Effect.tryPromise({
+          try: () => openWorkflowOverlay(ctx, registry, runId),
+          catch: (error) => error,
+        }),
+      ),
+    );
 
   pi.registerCommand("workflows", {
-    description: "Open the interactive workflow/task detail overlay. Usage: /workflows [runId | abort]",
+    description:
+      "Open the interactive workflow/task detail overlay. Usage: /workflows [runId | abort]",
     getArgumentCompletions(prefix: string) {
       const values = [
         "abort",
-        ...registry.list().map((handle) => handle.snapshot.runId).filter((runId): runId is string => Boolean(runId)),
+        ...registry
+          .list()
+          .map((handle) => handle.snapshot.runId)
+          .filter((runId): runId is string => Boolean(runId)),
       ];
       return [...new Set(values)]
         .filter((value) => value.startsWith(prefix))
         .map((value) => ({ value, label: value }));
     },
-    handler: async (args: string, ctx) => {
-      const arg = args.trim();
-      if (arg.toLowerCase() === "abort") {
-        registry.abortAll();
-        ctx.ui.notify("Requested abort of all active workflow runs.", "warning");
-        return;
-      }
-      await openWorkflows(ctx, arg || undefined);
-    },
+    handler: (args: string, ctx) =>
+      Effect.runPromise(
+        Effect.suspend(() => {
+          const arg = args.trim();
+          return arg.toLowerCase() === "abort"
+            ? attempt(() => {
+                registry.abortAll();
+                ctx.ui.notify("Requested abort of all active workflow runs.", "warning");
+              })
+            : openWorkflows(ctx, arg || undefined);
+        }),
+      ),
   });
 
   pi.registerShortcut("f6", {
     description: "Open workflow task details",
-    handler: async (ctx) => openWorkflows(ctx),
+    handler: (ctx) => Effect.runPromise(openWorkflows(ctx)),
   });
 }
 

package/src/depth.ts

@@ -12,12 +12,15 @@ export type AnalysisDepth = (typeof ANALYSIS_DEPTHS)[number];
 
 /** Canonical applicability and evidence requirements shared by all analysis-depth modes. */
 export const DEPTH_CRITERIA: Record<AnalysisDepth, string> = {
-  focused: "Bounded work with a known approach and locally verifiable results. Follow one line of inquiry and check the changed behavior or key claim directly (for example, a specified validation rule and its regression test). Do not skip verification; no broad investigation or adversarial panel by default.",
-  standard: "Multiple independent dimensions or unresolved hypotheses can materially change the answer. Investigate those dimensions or compare plausible causes, then use targeted verification to resolve disputed or weakly evidenced claims (for example, diagnosing a fault with several plausible causes). Known multi-step work alone does not require this depth.",
+  focused:
+    "Bounded work with a known approach and locally verifiable results. Follow one line of inquiry and check the changed behavior or key claim directly (for example, a specified validation rule and its regression test). Do not skip verification; no broad investigation or adversarial panel by default.",
+  standard:
+    "Multiple independent dimensions or unresolved hypotheses can materially change the answer. Investigate those dimensions or compare plausible causes, then use targeted verification to resolve disputed or weakly evidenced claims (for example, diagnosing a fault with several plausible causes). Known multi-step work alone does not require this depth.",
   deep: "Tightly interacting hard constraints or critical invariants require independent evidence and counterexamples. Trace the interactions, test boundary and failure cases, and challenge the key claims with a distinct check (for example, cancellation racing a durable commit). Risk keywords, file count, or a request for a review alone do not qualify; deep does not mandate extra agents or repeated rounds.",
 };
 
-export const DEPTH_SELECTION_RULES = "Choose the smallest depth that can establish correctness from the stated task and available evidence. Missing information is not proof of hidden complexity. Risk determines which claims need verification; security, concurrency, data loss, and other risk keywords alone never mandate deep. Depth determines investigation and evidence requirements, not model effort, agent count, or a mandatory number of rounds.";
+export const DEPTH_SELECTION_RULES =
+  "Choose the smallest depth that can establish correctness from the stated task and available evidence. Missing information is not proof of hidden complexity. Risk determines which claims need verification; security, concurrency, data loss, and other risk keywords alone never mandate deep. Depth determines investigation and evidence requirements, not model effort, agent count, or a mandatory number of rounds.";
 
 export const MODE_DESCRIPTIONS: Record<UltracodeModeName, string> = {
   off: "Workflow tool disabled; parent effort unchanged.",

package/src/effort-policy.ts

@@ -3,11 +3,14 @@ import { THINKING_LEVELS, type ThinkingLevel } from "./thinking.ts";
 /** Task-based effort criteria shared by workflow prompts and Jev selection. */
 const EFFORT_CRITERIA: Record<ThinkingLevel, string> = {
   off: "Fully specified mechanical work with no implementation decision or hidden-impact reasoning. Excludes finding where to change something or checking its meaning. Example: fix a typo at an exact location using a supplied replacement.",
-  minimal: "One clear local judgment in a single scope with no unresolved dependencies. Excludes cross-file tracing or multi-step implementation. Example: explain a short self-contained expression by checking its direct condition.",
+  minimal:
+    "One clear local judgment in a single scope with no unresolved dependencies. Excludes cross-file tracing or multi-step implementation. Example: explain a short self-contained expression by checking its direct condition.",
   low: "Small implementation or direct question with a clear goal, known approach, and straightforward checks. Excludes faults with an unknown root cause. Example: add a specified input validation rule and its test to an existing function.",
-  medium: "Bounded multi-step implementation or investigation coordinating several known constraints. Excludes interacting unresolved hypotheses requiring deeper investigation. Example: add a configuration option through loading, usage, and tests within an established architecture.",
+  medium:
+    "Bounded multi-step implementation or investigation coordinating several known constraints. Excludes interacting unresolved hypotheses requiring deeper investigation. Example: add a configuration option through loading, usage, and tests within an established architecture.",
   high: "Test multiple plausible hypotheses, trace cross-module effects, or reason about critical correctness constraints. Excludes escalation based solely on security or architecture keywords. Example: diagnose state desynchronization across modules by testing competing causes.",
-  xhigh: "Interacting hard problems requiring deep reasoning, comparison of approaches, and validation of cross-module invariants. Excludes escalation based only on file count or unsupported claims of complexity. Example: investigate an intermittent bug involving lifecycle, caching, and cancellation interactions.",
+  xhigh:
+    "Interacting hard problems requiring deep reasoning, comparison of approaches, and validation of cross-module invariants. Excludes escalation based only on file count or unsupported claims of complexity. Example: investigate an intermittent bug involving lifecycle, caching, and cancellation interactions.",
   max: "Exceptionally difficult synthesis requiring sustained rigorous argument and adversarial validation, or concrete evidence that lower-effort reasoning is insufficient. Excludes escalation from risk keywords alone; prior lower-level failure is not required. Example: prove and repair system-wide invariants involving concurrency, memory safety, and low-level semantics.",
 };
 

package/src/index.ts

@@ -21,8 +21,17 @@ export {
 } from "./prompts.ts";
 
 export { createWorkflowTool, type WorkflowToolDeps } from "./workflow/tool.ts";
-export { runWorkflow, type WorkflowRunOptions, type WorkflowRunResult } from "./workflow/runtime.ts";
-export { parseWorkflowScript, normalizeScript, type WorkflowMeta, type WorkflowMetaPhase } from "./workflow/parser.ts";
+export {
+  runWorkflow,
+  type WorkflowRunOptions,
+  type WorkflowRunResult,
+} from "./workflow/runtime.ts";
+export {
+  parseWorkflowScript,
+  normalizeScript,
+  type WorkflowMeta,
+  type WorkflowMetaPhase,
+} from "./workflow/parser.ts";
 export { jsonSchemaToTypeBox } from "./workflow/json-schema.ts";
 export {
   WorkflowAgentRunner,
@@ -40,7 +49,10 @@ export {
   type ModelRuntimeFactory,
   type ModelRuntimeLike,
 } from "./workflow/agent-runner.ts";
-export { createStructuredOutputTool, type StructuredOutputCapture } from "./workflow/structured-output.ts";
+export {
+  createStructuredOutputTool,
+  type StructuredOutputCapture,
+} from "./workflow/structured-output.ts";
 export {
   discoverAgentTypes,
   resolveAgentType,