@zachwill/pi-orchestrate 0.1.1 → 0.2.0

package/extension/scheduler.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Exit, FiberMap, Scope } from "effect";
+import { Cause, Context, Effect, FiberMap, Layer, ManagedRuntime } from "effect";
 
 export type WorkflowDefectHandler = (error: unknown) => void;
 
@@ -6,7 +6,7 @@ export interface WorkflowScheduler<Key> {
   /** Starts a workflow immediately, interrupting and replacing the previous workflow at the key. */
   start(
     key: Key,
-    workflow: () => Promise<void>,
+    workflow: Effect.Effect<void, never>,
     onDefect: WorkflowDefectHandler,
   ): void;
   /** Interrupts the current workflow at the key and waits for its fiber to settle. */
@@ -15,48 +15,67 @@ export interface WorkflowScheduler<Key> {
   close(): Promise<void>;
 }
 
+interface WorkflowSupervisorService {
+  readonly start: (
+    key: unknown,
+    workflow: Effect.Effect<void, never>,
+  ) => void;
+  readonly remove: (key: unknown) => Effect.Effect<void>;
+}
+
+class WorkflowSupervisor extends Context.Service<
+  WorkflowSupervisor,
+  WorkflowSupervisorService
+>()("@zachwill/pi-orchestrate/WorkflowSupervisor") {}
+
+const workflowSupervisorLayer = Layer.effect(
+  WorkflowSupervisor,
+  Effect.gen(function* () {
+    const fibers = yield* FiberMap.make<unknown, void, never>();
+    const run = yield* FiberMap.runtime(fibers)<never>();
+    return WorkflowSupervisor.of({
+      start(key, workflow) {
+        run(key, workflow);
+      },
+      remove: (key) => FiberMap.remove(fibers, key),
+    });
+  }),
+);
+
 class EffectWorkflowScheduler<Key> implements WorkflowScheduler<Key> {
-  private readonly scope = Scope.makeUnsafe("parallel");
-  private readonly fibers: FiberMap.FiberMap<Key, void, never>;
+  private readonly managedRuntime = ManagedRuntime.make(workflowSupervisorLayer);
+  private readonly supervisor = this.managedRuntime.runSync(WorkflowSupervisor);
   private closePromise: Promise<void> | undefined;
 
-  constructor() {
-    this.fibers = Effect.runSync(
-      Scope.provide(this.scope)(FiberMap.make<Key, void, never>()),
-    );
-  }
-
   start(
     key: Key,
-    workflow: () => Promise<void>,
+    workflow: Effect.Effect<void, never>,
     onDefect: WorkflowDefectHandler,
   ): void {
-    const supervised = Effect.promise(workflow).pipe(
+    const supervised = workflow.pipe(
       Effect.catchCause((cause) => {
         if (!Cause.hasInterruptsOnly(cause)) {
-          try {
-            onDefect(Cause.squash(cause));
-          } catch {
-            // Defect reporting must not become another unsupervised defect.
-          }
+          return Effect.sync(() => {
+            try {
+              onDefect(Cause.squash(cause));
+            } catch {
+              // Defect reporting must not become another unsupervised defect.
+            }
+          });
         }
         return Effect.void;
       }),
     );
 
-    Effect.runSync(
-      FiberMap.run(this.fibers, key, supervised, { startImmediately: true }),
-    );
+    this.supervisor.start(key, supervised);
   }
 
-  async remove(key: Key): Promise<void> {
-    await Effect.runPromise(FiberMap.remove(this.fibers, key));
+  remove(key: Key): Promise<void> {
+    return this.managedRuntime.runPromise(this.supervisor.remove(key));
   }
 
   close(): Promise<void> {
-    if (!this.closePromise) {
-      this.closePromise = Effect.runPromise(Scope.close(this.scope, Exit.void));
-    }
+    this.closePromise ??= this.managedRuntime.dispose();
     return this.closePromise;
   }
 }

package/extension/tools.ts

@@ -4,7 +4,15 @@ import type {
   ExtensionContext,
   Theme,
 } from "@earendil-works/pi-coding-agent";
-import { Container, Markdown, Spacer, Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import {
+  Container,
+  Markdown,
+  Spacer,
+  Text,
+  truncateToWidth,
+  wrapTextWithAnsi,
+  type Component,
+} from "@earendil-works/pi-tui";
 import {
   formatSize,
   getAgentDir,
@@ -37,6 +45,7 @@ import type {
 
 const STRICT_OBJECT = { additionalProperties: false } as const;
 const MAX_TASKS_PER_WAVE = 12;
+const MAX_INSTRUCTION_PREVIEW_LINES = 2;
 
 const taskSchema = Type.Object(
   {
@@ -512,7 +521,7 @@ function catalogWorkerDetails(worker: WorkerDefinition) {
       file_path: worker.source.filePath,
     },
     tools: [...worker.tools],
-    skills: [...worker.skills],
+    skills: worker.skills === undefined ? undefined : [...worker.skills],
     model: worker.model
       ? { provider: worker.model.provider, model_id: worker.model.modelId }
       : undefined,
@@ -603,42 +612,62 @@ function readableDetails(title: string, details: unknown): string {
   return `${truncation.content}\n\n[Output truncated: ${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}. Full structured details remain available.]`;
 }
 
+interface RenderableTask {
+  readonly worker?: unknown;
+  readonly title?: unknown;
+  readonly instructions?: unknown;
+}
+
 function renderDispatchCall(
   theme: Theme,
-  tasks: readonly { worker: string; title: string; instructions: string }[],
+  tasks: readonly RenderableTask[] | undefined,
   expanded: boolean,
 ): Component {
   const container = new Container();
-  const count = tasks.length;
+  const renderableTasks = Array.isArray(tasks) ? tasks : [];
+  const count = renderableTasks.length;
   container.addChild(new Text(
     theme.fg("toolTitle", theme.bold("orchestrate ")) + theme.fg("muted", `${count} worker${count === 1 ? "" : "s"}`),
     0, 0,
   ));
   if (expanded) {
-    for (const task of tasks) {
+    for (const task of renderableTasks) {
       container.addChild(new Spacer(1));
-      container.addChild(new Text(`${theme.fg("accent", "→")} ${theme.fg("muted", task.worker)} · ${theme.fg("text", theme.bold(task.title))}`, 0, 0));
+      container.addChild(new Text(`${theme.fg("accent", "→")} ${theme.fg("muted", safeTerminalText(task.worker))} · ${theme.fg("text", theme.bold(safeTerminalText(task.title)))}`, 0, 0));
       container.addChild(new Text(safeTerminalText(task.instructions), 2, 0));
     }
     return new WidthBoundComponent(container);
   }
-  container.addChild(new InstructionPreview(tasks, theme));
+  container.addChild(new InstructionPreview(renderableTasks, theme));
   container.addChild(new Text(theme.fg("dim", keyHint("app.tools.expand", "to inspect full instructions")), 0, 0));
   return new WidthBoundComponent(container);
 }
 
 class InstructionPreview implements Component {
   constructor(
-    private readonly tasks: readonly { worker: string; title: string; instructions: string }[],
+    private readonly tasks: readonly RenderableTask[],
     private readonly theme: Theme,
   ) {}
   render(width: number): string[] {
     const bounded = Math.max(1, width);
-    return this.tasks.map((task) => {
-      const preview = firstInstructionLine(task.instructions) ?? "";
-      const row = `${this.theme.fg("accent", "→")} ${safeTerminalText(task.worker)} · ${safeTerminalText(task.title)}${preview ? ` — ${safeTerminalText(preview)}` : ""}`;
-      return truncateToWidth(row, bounded, "…");
-    });
+    const lines: string[] = [];
+    for (const task of this.tasks) {
+      const heading = `${this.theme.fg("accent", "→")} ${this.theme.fg("muted", safeTerminalText(task.worker))} · ${this.theme.fg("text", this.theme.bold(safeTerminalText(task.title)))}`;
+      lines.push(truncateToWidth(heading, bounded, "…"));
+
+      const contentWidth = Math.max(1, bounded - 2);
+      const characterLimit = Math.max(256, Math.min(4096, contentWidth * 3));
+      const preview = compactInstructionPreview(task.instructions, characterLimit);
+      if (!preview.text) continue;
+      const wrapped = wrapTextWithAnsi(preview.text, contentWidth);
+      const previewLines = wrapped.slice(0, MAX_INSTRUCTION_PREVIEW_LINES);
+      if (preview.truncated || wrapped.length > MAX_INSTRUCTION_PREVIEW_LINES) {
+        const lastIndex = previewLines.length - 1;
+        previewLines[lastIndex] = truncateToWidth(`${previewLines[lastIndex] ?? ""}…`, contentWidth, "…");
+      }
+      for (const line of previewLines) lines.push(this.theme.fg("dim", `  ${line}`));
+    }
+    return lines.map((line) => truncateToWidth(line, bounded, "…"));
   }
   invalidate(): void {}
 }
@@ -646,12 +675,12 @@ class InstructionPreview implements Component {
 function renderWorkerMessageCall(
   theme: Theme,
   tool: string,
-  workerId: string,
-  instructions: string,
+  workerId: unknown,
+  instructions: unknown,
   expanded: boolean,
 ): Component {
   const container = new Container();
-  container.addChild(new Text(theme.fg("toolTitle", theme.bold(`${tool} `)) + theme.fg("muted", workerId), 0, 0));
+  container.addChild(new Text(theme.fg("toolTitle", theme.bold(`${tool} `)) + theme.fg("muted", safeTerminalText(workerId)), 0, 0));
   if (expanded) container.addChild(new Text(safeTerminalText(instructions), 2, 0));
   else {
     container.addChild(new Text(`${theme.fg("accent", "→")} ${truncateInstruction(instructions, 240)}`, 0, 0));
@@ -672,25 +701,36 @@ class WidthBoundComponent implements Component {
   dispose(): void { (this.child as Component & { dispose?: () => void }).dispose?.(); }
 }
 
-function safeTerminalText(value: string): string {
-  return value.replace(/\r\n?/g, "\n").replace(/\t/g, "    ").replace(/[\x00-\x08\x0B-\x1F\x7F]/g, (character) => {
+function safeTerminalText(value: unknown): string {
+  const text = typeof value === "string" ? value : value == null ? "" : String(value);
+  return text.replace(/\r\n?/g, "\n").replace(/\t/g, "    ").replace(/[\x00-\x08\x0B-\x1F\x7F]/g, (character) => {
     const code = character.charCodeAt(0);
     return code === 0x7f ? "␡" : String.fromCodePoint(0x2400 + code);
   });
 }
 
-function firstInstructionLine(instructions: string): string | undefined {
-  return instructions.split(/\r\n?|\n/).find((line) => line.trim().length > 0);
+function compactInstructionPreview(instructions: unknown, characterLimit: number): { text: string; truncated: boolean } {
+  const text = typeof instructions === "string" ? instructions : instructions == null ? "" : String(instructions);
+  const source = text.slice(0, characterLimit);
+  return {
+    text: safeTerminalText(source).replace(/\s+/g, " ").trim(),
+    truncated: source.length < text.length,
+  };
+}
+
+function firstInstructionLine(instructions: unknown): string | undefined {
+  const text = typeof instructions === "string" ? instructions : instructions == null ? "" : String(instructions);
+  return text.split(/\r\n?|\n/).find((line) => line.trim().length > 0);
 }
 
-function truncateInstruction(instructions: string, limit: number): string {
+function truncateInstruction(instructions: unknown, limit: number): string {
   const first = firstInstructionLine(instructions) ?? "";
   return first.length > limit ? `${first.slice(0, limit - 1)}…` : first;
 }
 
-function renderCompactCall(theme: Theme, tool: string, target: string): Text {
+function renderCompactCall(theme: Theme, tool: string, target: unknown): Text {
   return new Text(
-    theme.fg("toolTitle", theme.bold(`${tool} `)) + theme.fg("muted", target),
+    theme.fg("toolTitle", theme.bold(`${tool} `)) + theme.fg("muted", safeTerminalText(target)),
     0,
     0,
   );