pi-ultracode 0.1.0 → 0.1.2

package/extensions/ultracode.ts

@@ -2,23 +2,47 @@
  * pi-ultracode extension entrypoint.
  *
  * Wires together the three pillars of Claude-Code-style "ultracode":
- *   1. The ultracode effort mode (xhigh thinking + standing workflow opt-in).
+ *   1. The ultracode effort mode (max thinking + standing workflow opt-in).
  *   2. The full `workflow` orchestration tool.
  *   3. The `/ultracode` and `/workflows` commands.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  getAgentDir,
+  SettingsManager,
+  VERSION as PI_VERSION,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
 import { createWorkflowTool, type WorkflowToolDeps } from "../src/workflow/tool.ts";
-import { UltracodeMode } from "../src/mode.ts";
+import { UltracodeMode, type ThinkingPreferenceStore } from "../src/mode.ts";
+import { isThinkingLevel, piVersionSupportsMaxThinking } from "../src/thinking.ts";
 import { registerCommands } from "../src/commands.ts";
 
-export default function extension(pi: ExtensionAPI, extraDeps: Partial<WorkflowToolDeps> = {}): void {
+export interface ThinkingPreferenceContext {
+  cwd: string;
+  projectTrusted: boolean;
+}
+
+export interface UltracodeExtensionDeps extends Partial<WorkflowToolDeps> {
+  /** SDK-host seam when the active profile differs from Pi's ambient agent dir. */
+  createThinkingPreferenceStore?: (
+    context: ThinkingPreferenceContext,
+  ) => ThinkingPreferenceStore | undefined;
+}
+
+export default function extension(pi: ExtensionAPI, extraDeps: UltracodeExtensionDeps = {}): void {
   const mode = new UltracodeMode("workflow");
+  mode.setRuntimeSupportsMaxThinking(piVersionSupportsMaxThinking(PI_VERSION));
+  const {
+    createThinkingPreferenceStore = createPiThinkingPreferenceStore,
+    ...workflowDeps
+  } = extraDeps;
 
   const workflowTool = createWorkflowTool({
     getDefaultBudget: () => mode.getBudget(),
     getThinkingLevel: () => mode.getSubagentThinkingLevel(),
-    ...extraDeps,
+    ...workflowDeps,
+    isExecutionAllowed: () => mode.isEnforcing(),
   });
   pi.registerTool(workflowTool);
 
@@ -27,30 +51,124 @@ export default function extension(pi: ExtensionAPI, extraDeps: Partial<WorkflowT
   // Opt-in via CLI flag: `pi --ultracode`.
   pi.registerFlag("ultracode", {
     type: "boolean",
-    description: "Start the session in ultracode mode (xhigh thinking + default workflow orchestration).",
+    description: "Start the session in ultracode mode (max thinking + default workflow orchestration).",
   });
 
-  pi.on("session_start", (_event, ctx) => {
+  // SDK-created sessions can prompt without emitting session_start. Sync during
+  // input preflight so before_agent_start receives Pi's rebuilt base prompt.
+  pi.on("input", () => {
+    mode.syncWorkflowTool(pi);
+  });
+
+  // Fail closed if another active-tool writer re-exposes workflow while the
+  // mode is off or quiescing.
+  pi.on("tool_call", (event) => {
+    if (event.toolName === workflowTool.name && !mode.isEnforcing()) {
+      return {
+        block: true,
+        reason: "The workflow tool is disabled. Run /ultracode on before using it.",
+      };
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    await mode.flushThinkingPreference();
+    mode.setCurrentModelSupportsThinking(ctx.model ? Boolean(ctx.model.reasoning) : undefined);
+    try {
+      mode.bindThinkingPreferenceStore(createThinkingPreferenceStore({
+        cwd: ctx.cwd,
+        projectTrusted: ctx.isProjectTrusted(),
+      }));
+    } catch {
+      mode.bindThinkingPreferenceStore(undefined);
+    }
     // Restore persisted mode state across reload / resume / fork.
     try {
-      mode.restore(pi, ctx.sessionManager.getEntries() as any);
+      // Mode entries are branch-local; discarded future branches must not win.
+      mode.restore(pi, ctx.sessionManager.getBranch() as any);
     } catch {
       // ignore
     }
     if (!mode.isEnabled() && pi.getFlag?.("ultracode") === true) {
       mode.enable(pi);
     }
-    // Always keep the workflow tool available so the model can use it on request.
-    try {
-      const active = pi.getActiveTools();
-      if (!active.includes(workflowTool.name)) pi.setActiveTools([...active, workflowTool.name]);
-    } catch {
-      // ignore
+    // Registration makes extension tools discoverable; activation remains opt-in.
+    mode.syncWorkflowTool(pi);
+    await mode.flushThinkingPreference();
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("ultracode", mode.isEnabled() ? mode.statusLine() : undefined);
     }
-    if (ctx.hasUI && mode.isEnabled()) ctx.ui.setStatus("ultracode", mode.statusLine());
   });
 
-  pi.on("before_agent_start", (event) => {
+  pi.on("session_tree", async (_event, ctx) => {
+    await mode.flushThinkingPreference();
+    if (mode.isSuspended()) return;
+    mode.setCurrentModelSupportsThinking(ctx.model ? Boolean(ctx.model.reasoning) : undefined);
+    mode.restore(pi, ctx.sessionManager.getBranch() as any);
+    await mode.flushThinkingPreference();
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("ultracode", mode.isEnabled() ? mode.statusLine() : undefined);
+    }
+  });
+
+  pi.on("model_select", async (event, ctx) => {
+    mode.setCurrentModelSupportsThinking(Boolean(event.model.reasoning));
+    const refreshStatus = mode.handleModelSelect(pi);
+    await mode.flushThinkingPreference();
+    if (refreshStatus && ctx.hasUI) ctx.ui.setStatus("ultracode", mode.statusLine());
+  });
+
+  pi.on("thinking_level_select", async (event, ctx) => {
+    if (!mode.handleThinkingLevelSelect(pi, event.level)) return;
+    await mode.flushThinkingPreference();
+    if (ctx.hasUI) ctx.ui.setStatus("ultracode", mode.statusLine());
+  });
+
+  pi.on("session_shutdown", async () => {
+    // Quiesce first so late model/effort events cannot undo restoration. The
+    // persisted enabled state remains on for reload/resume/fork replacements.
+    mode.suspend(pi);
+    await mode.flushThinkingPreference();
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    // Reconcile the tool schema and always append the standing block on an
+    // enforcing turn, even when another active-tool writer caused drift.
+    mode.syncWorkflowTool(pi);
+    mode.reapplyMaximumThinking(pi);
+    await mode.flushThinkingPreference();
     return mode.beforeAgentStart(event);
   });
 }
+
+function createPiThinkingPreferenceStore(
+  context: ThinkingPreferenceContext,
+): ThinkingPreferenceStore {
+  const createSettings = () => SettingsManager.create(
+    context.cwd,
+    getAgentDir(),
+    { projectTrusted: context.projectTrusted },
+  );
+  return {
+    getThinkingPreference() {
+      // Use a fresh manager so a selection made after session_start is visible;
+      // SettingsManager instances intentionally keep their own cached snapshot.
+      const settings = createSettings();
+      const global = settings.getGlobalSettings().defaultThinkingLevel;
+      const effective = settings.getDefaultThinkingLevel();
+      return {
+        global: isThinkingLevel(global) ? global : undefined,
+        effective: isThinkingLevel(effective) ? effective : "medium",
+      };
+    },
+    async setDefaultThinkingLevel(level) {
+      // Use a fresh queue after the mode's macrotask barrier. This serializes
+      // behind Pi's already-enqueued writes instead of racing a long-lived peer.
+      const settings = createSettings();
+      // An absent setting is semantically Pi's `medium` default. SettingsManager
+      // has no unset operation, so restore that equivalent value explicitly.
+      settings.setDefaultThinkingLevel((level ?? "medium") as any);
+      await settings.flush();
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ultracode",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Claude-Code-style \"ultracode\" for Pi: an effort mode that defaults to deterministic multi-agent workflow orchestration, with worktree isolation, per-agent model overrides, custom agent types, nested workflows, token budgets, resumable runs, and a /workflows manager.",
   "type": "module",
   "keywords": [
@@ -16,6 +16,14 @@
   ],
   "author": "pi-ultracode",
   "license": "MIT",
+  "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/",
@@ -23,6 +31,10 @@
     "examples/",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "pi": {
     "extensions": [
       "./extensions/ultracode.ts"
@@ -40,6 +52,15 @@
   "dependencies": {
     "acorn": "^8.11.0"
   },
+  "devDependencies": {
+    "@earendil-works/pi-agent-core": "^0.80.10",
+    "@earendil-works/pi-ai": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
+    "@earendil-works/pi-tui": "^0.80.10",
+    "@types/node": "^24.12.4",
+    "typebox": "1.1.38",
+    "typescript": "^5.9.3"
+  },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",

package/src/commands.ts

@@ -5,24 +5,30 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { parseBudget, type UltracodeMode } from "./mode.ts";
 import { getRegistry } from "./workflow/registry.ts";
-import { renderWorkflowLines } from "./workflow/display.ts";
+import { workflowRunsDir } from "./workflow/tool.ts";
+import { openWorkflowOverlay } from "./workflow/workflow-overlay.ts";
 
 export function registerCommands(pi: ExtensionAPI, mode: UltracodeMode): void {
   pi.registerCommand("ultracode", {
-    description: "Toggle ultracode mode (xhigh thinking + default workflow orchestration). Bare /ultracode toggles; subcommands: on|off|status|budget <n>",
+    description: "Toggle ultracode mode (max thinking + default workflow orchestration). Bare /ultracode toggles; subcommands: on|off|status|budget <n>",
     getArgumentCompletions(prefix: string) {
       return ["on", "off", "status", "budget"]
         .filter((s) => s.startsWith(prefix))
         .map((value) => ({ value, label: value }));
     },
     handler: async (args: string, ctx) => {
+      mode.setCurrentModelSupportsThinking(ctx.model ? Boolean(ctx.model.reasoning) : undefined);
       const parts = args.trim().split(/\s+/).filter(Boolean);
       const sub = (parts[0] ?? "").toLowerCase();
 
       // Bare `/ultracode` is a toggle.
       if (sub === "") {
         const nowOn = mode.toggle(pi);
-        ctx.ui.notify(nowOn ? `Ultracode on — ${mode.statusLine()}` : "Ultracode off — thinking restored.", "info");
+        await mode.flushThinkingPreference();
+        ctx.ui.notify(
+          nowOn ? `Ultracode on — ${mode.statusLine()}` : "Ultracode off — thinking restored and workflow tool disabled.",
+          "info",
+        );
         ctx.ui.setStatus("ultracode", nowOn ? mode.statusLine() : undefined);
         return;
       }
@@ -34,7 +40,8 @@ export function registerCommands(pi: ExtensionAPI, mode: UltracodeMode): void {
 
       if (sub === "off") {
         mode.disable(pi);
-        ctx.ui.notify("Ultracode off — thinking restored, workflow orchestration is opt-in again.", "info");
+        await mode.flushThinkingPreference();
+        ctx.ui.notify("Ultracode off — thinking restored and workflow tool disabled.", "info");
         ctx.ui.setStatus("ultracode", undefined);
         return;
       }
@@ -58,6 +65,7 @@ export function registerCommands(pi: ExtensionAPI, mode: UltracodeMode): void {
         if (parsed) budget = parsed;
       }
       mode.enable(pi, budget !== undefined ? { budget } : {});
+      await mode.flushThinkingPreference();
       ctx.ui.notify(
         `Ultracode on — ${mode.statusLine()}${budget ? ` (budget ~${budget} tokens)` : ""}`,
         "info",
@@ -66,96 +74,36 @@ export function registerCommands(pi: ExtensionAPI, mode: UltracodeMode): void {
     },
   });
 
-  // Tracks whether the run panel is currently shown, so bare /workflows toggles it.
-  let panelVisible = false;
+  const openWorkflows = async (ctx: any, runId?: string) => {
+    const registry = getRegistry();
+    registry.restoreRuns(workflowRunsDir(ctx));
+    await openWorkflowOverlay(ctx, registry, runId);
+  };
 
   pi.registerCommand("workflows", {
-    description: "Toggle the workflow-run panel. Usage: /workflows [runId | clear | abort]",
+    description: "Open the interactive workflow/task detail overlay. Usage: /workflows [runId | abort]",
     getArgumentCompletions(prefix: string) {
-      return ["clear", "abort"]
-        .filter((s) => s.startsWith(prefix))
+      const values = [
+        "abort",
+        ...getRegistry().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 registry = getRegistry();
       const arg = args.trim();
-      const sub = arg.toLowerCase();
-
-      const hide = () => {
-        ctx.ui.setWidget("ultracode-workflows", undefined);
-        panelVisible = false;
-      };
-      const show = (lines: string[]) => {
-        ctx.ui.setWidget("ultracode-workflows", lines);
-        panelVisible = true;
-      };
-
-      if (sub === "clear" || sub === "hide" || sub === "off") {
-        hide();
-        ctx.ui.notify("Workflow panel hidden.", "info");
-        return;
-      }
-
-      if (sub === "abort") {
-        registry.abortAll();
-        hide();
-        ctx.ui.notify("Requested abort of all active workflow runs; panel hidden.", "info");
-        return;
-      }
-
-      const runs = registry.list();
-
-      // Explicit run id -> show that run's detail.
-      if (arg) {
-        const handle = registry.get(arg) ?? runs.find((r) => r.snapshot.runId?.startsWith(arg));
-        if (!handle) {
-          ctx.ui.notify(`No workflow run matching "${arg}". /workflows to list, /workflows clear to hide.`, "warning");
-          return;
-        }
-        show(renderWorkflowLines(handle.snapshot, { maxAgents: 12, maxLogs: 6, showResultPreviews: true, showStream: true }));
-        ctx.ui.notify(`Showing ${handle.snapshot.runId ?? "run"}. /workflows clear to hide.`, "info");
+      if (arg.toLowerCase() === "abort") {
+        getRegistry().abortAll();
+        ctx.ui.notify("Requested abort of all active workflow runs.", "warning");
         return;
       }
-
-      // Bare /workflows toggles the panel off if it's already up.
-      if (panelVisible) {
-        hide();
-        ctx.ui.notify("Workflow panel hidden.", "info");
-        return;
-      }
-
-      if (runs.length === 0) {
-        hide();
-        ctx.ui.notify("No workflow runs in this session yet.", "info");
-        return;
-      }
-
-      const summary = runs.map((handle) => {
-        const s = handle.snapshot;
-        return `${statusGlyph(s.status)} ${s.runId}  ${s.name}  ${s.doneCount}/${s.agentCount}${
-          s.runningCount ? ` (${s.runningCount} running)` : ""
-        }`;
-      });
-      show(["◆ Ultracode workflow runs  ·  /workflows clear to hide", ...summary.map((l) => `  ${l}`)]);
-      ctx.ui.notify(
-        `${runs.length} run(s), ${registry.active().length} active. /workflows again (or /workflows clear) to hide.`,
-        "info",
-      );
+      await openWorkflows(ctx, arg || undefined);
     },
   });
-}
 
-function statusGlyph(status: string): string {
-  switch (status) {
-    case "completed":
-      return "✓";
-    case "running":
-      return "▶";
-    case "aborted":
-      return "■";
-    case "failed":
-      return "✗";
-    default:
-      return "·";
-  }
+  pi.registerShortcut("f6", {
+    description: "Open workflow task details",
+    handler: async (ctx) => openWorkflows(ctx),
+  });
 }

package/src/index.ts

@@ -22,9 +22,15 @@ export {
   matchModelIn,
   type AgentRunCall,
   type AgentRunResult,
+  type AgentTelemetryEvent,
+  type AgentTurnUsage,
+  type AgentUsage,
   type ThinkingLevel,
   type ModelLike,
   type ModelRegistryLike,
+  type ModelRuntimeCreateOptions,
+  type ModelRuntimeFactory,
+  type ModelRuntimeLike,
 } from "./workflow/agent-runner.ts";
 export { createStructuredOutputTool, type StructuredOutputCapture } from "./workflow/structured-output.ts";
 export {
@@ -42,8 +48,22 @@ export {
   renderWorkflowLines,
   renderWorkflowText,
   preview,
+  type WorkflowAgentSnapshot,
+  type WorkflowAgentUsageSnapshot,
   type WorkflowSnapshot,
 } from "./workflow/display.ts";
+export {
+  WorkflowRunDetails,
+  MAX_LIVE_TASK_BYTES,
+  MAX_LIVE_TASK_LINES,
+  MAX_LIVE_RUN_BYTES,
+  MAX_TASK_TRANSCRIPT_BYTES,
+  MAX_RUN_TRANSCRIPT_BYTES,
+  type WorkflowTaskDetail,
+  type WorkflowTaskSummary,
+  type WorkflowTaskUsage,
+  type WorkflowTimelineEvent,
+} from "./workflow/run-details.ts";
 export {
   createWorktree,
   captureWorktreeDiff,