@zachwill/pi-orchestrate 0.9.0 → 0.10.0

package/extension/{presentation.ts → pi/presentation.ts}

@@ -15,9 +15,12 @@ import {
   type Component,
 } from "@earendil-works/pi-tui";
 import { Result } from "effect";
-import type { WorkerDeliveryDetails } from "./delivery.js";
-import type { WorkerOutcome, WorkerRecord, WorkerStatus } from "./domain.js";
-import type { RuntimeSnapshot } from "./runtime.js";
+import type {
+  WorkerOutcome,
+  WorkerRecord,
+  WorkerStatus,
+} from "../orchestration/model.js";
+import type { OwnerSnapshot } from "../orchestration/service.js";
 import {
   disposeComponent,
   formatElapsed,
@@ -25,9 +28,9 @@ import {
   WidthBoundComponent,
 } from "./tui.js";
 import {
-  decodePersistedWorkerSettlementDetails,
-  type WorkerSettlementDetails,
-} from "./worker-settlement.js";
+  decodePersistedWorkerSettlement,
+  type WorkerSettlement,
+} from "../orchestration/settlement.js";
 
 export const ORCHESTRATION_PRESENTATION_KEY = "pi-orchestrate";
 export const MAX_RESULT_PREVIEW_LINES = 6;
@@ -51,10 +54,11 @@ const ANIMATION_CYCLE_TICKS = 40;
 const SPINNER_INTERVAL_MS = 140;
 const ACTIVE_STATUSES: ReadonlySet<WorkerStatus> = new Set(["starting", "running", "stopping"]);
 
-export interface PresentationRuntime {
+/** Owner-scoped worker state feed consumed by the parent's status presentation. */
+export interface WorkerStateSource {
   subscribeState(
     ownerSessionId: string,
-    listener: (snapshot: RuntimeSnapshot) => void,
+    listener: (snapshot: OwnerSnapshot) => void,
   ): () => void;
 }
 
@@ -66,14 +70,14 @@ interface StatusBinding {
 interface RenderRequester { requestRender(): void }
 
 export function registerOrchestrationPresentation(pi: ExtensionAPI): void {
-  pi.registerMessageRenderer<WorkerDeliveryDetails>(
+  pi.registerMessageRenderer<WorkerSettlement>(
     "pi-orchestrate-worker-result",
     (message, { expanded }, theme) =>
       new WorkerResultComponent(messageText(message.content), message.details, expanded, theme),
   );
 }
 
-export function formatFooterStatus(snapshot: RuntimeSnapshot): string | undefined {
+export function formatFooterStatus(snapshot: OwnerSnapshot): string | undefined {
   const ready = snapshot.workers.filter((worker) => worker.status === "ready").length;
   return ready > 0 ? `${ready} interactive ready` : undefined;
 }
@@ -83,17 +87,15 @@ export class StatusController {
   private disposed = false;
   private unsubscribeState: (() => void) | undefined;
   private widget: WorkerStatusComponent | undefined;
-  private widgetInstalled = false;
-  private pendingSnapshot: RuntimeSnapshot | undefined;
 
-  constructor(private readonly runtime: PresentationRuntime) {}
+  constructor(private readonly workerState: WorkerStateSource) {}
 
   bind(ownerSessionId: string, ctx: ExtensionContext): void {
     if (this.disposed) return;
     this.clearBinding();
     const binding = { ownerSessionId, ctx };
     this.binding = binding;
-    this.unsubscribeState = this.runtime.subscribeState(ownerSessionId, (snapshot) => {
+    this.unsubscribeState = this.workerState.subscribeState(ownerSessionId, (snapshot) => {
       if (this.binding !== binding) return;
       this.present(binding.ctx, snapshot);
     });
@@ -110,59 +112,60 @@ export class StatusController {
     this.clearBinding();
   }
 
-  private present(ctx: ExtensionContext, snapshot: RuntimeSnapshot): void {
+  private present(ctx: ExtensionContext, snapshot: OwnerSnapshot): void {
     ctx.ui.setStatus(ORCHESTRATION_PRESENTATION_KEY, formatFooterStatus(snapshot));
     if (ctx.mode !== "tui") return;
     const active = activeWorkers(snapshot);
-    this.pendingSnapshot = snapshot;
     if (active.length === 0) {
-      if (this.widgetInstalled) ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
-      this.widget = undefined;
-      this.widgetInstalled = false;
+      if (this.widget !== undefined) {
+        ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
+        this.widget = undefined;
+      }
       return;
     }
-    if (this.widget) {
+    if (this.widget !== undefined) {
       this.widget.update(snapshot);
       return;
     }
-    if (this.widgetInstalled) return;
     ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, (tui, theme) => {
-      this.widget = new WorkerStatusComponent(this.pendingSnapshot ?? snapshot, theme, tui);
-      return this.widget;
+      const widget = new WorkerStatusComponent(snapshot, theme, tui);
+      this.widget = widget;
+      return widget;
     }, { placement: "aboveEditor" });
-    this.widgetInstalled = true;
   }
 
   private clearBinding(): void {
     const unsubscribeState = this.unsubscribeState;
     this.unsubscribeState = undefined;
     unsubscribeState?.();
-    this.widget = undefined;
-    this.pendingSnapshot = undefined;
     const current = this.binding;
     if (!current) return;
     current.ctx.ui.setStatus(ORCHESTRATION_PRESENTATION_KEY, undefined);
-    if (current.ctx.mode === "tui" && this.widgetInstalled) current.ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
-    this.widgetInstalled = false;
+    if (current.ctx.mode === "tui" && this.widget !== undefined) {
+      current.ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
+      this.widget = undefined;
+    }
     this.binding = undefined;
   }
 }
 
-export function createStatusController(runtime: PresentationRuntime): StatusController {
-  return new StatusController(runtime);
+export function createStatusController(
+  workerState: WorkerStateSource,
+): StatusController {
+  return new StatusController(workerState);
 }
 
 export class WorkerStatusComponent implements Component {
   private frameIndex = 0;
-  private snapshot: RuntimeSnapshot;
+  private snapshot: OwnerSnapshot;
   private timer: ReturnType<typeof setInterval> | undefined;
 
-  constructor(snapshot: RuntimeSnapshot, private readonly theme: Theme, private readonly tui?: RenderRequester) {
+  constructor(snapshot: OwnerSnapshot, private readonly theme: Theme, private readonly tui?: RenderRequester) {
     this.snapshot = snapshot;
     this.startTimer();
   }
 
-  update(snapshot: RuntimeSnapshot): void {
+  update(snapshot: OwnerSnapshot): void {
     this.snapshot = snapshot;
     if (activeWorkers(snapshot).length > 0) this.startTimer();
     else this.stopTimer();
@@ -292,8 +295,8 @@ export class WorkerResultComponent implements Component {
   }
 }
 
-function readSettlement(value: unknown): WorkerSettlementDetails | undefined {
-  const decoded = decodePersistedWorkerSettlementDetails(value);
+function readSettlement(value: unknown): WorkerSettlement | undefined {
+  const decoded = decodePersistedWorkerSettlement(value);
   return Result.isSuccess(decoded) ? decoded.success : undefined;
 }
 
@@ -310,7 +313,7 @@ function outcomeText(outcome: WorkerOutcome): string {
   return "Worker session closed.";
 }
 
-function presentedOutcome(result: WorkerSettlementDetails): string {
+function presentedOutcome(result: WorkerSettlement): string {
   const body = outcomeText(result.outcome);
   if (result.status !== "completed" && result.status !== "ready") return body;
 
@@ -325,7 +328,7 @@ function presentedOutcome(result: WorkerSettlementDetails): string {
   return lines.join("\n").trimEnd();
 }
 
-function settlementMetadata(result: WorkerSettlementDetails): string[] {
+function settlementMetadata(result: WorkerSettlement): string[] {
   return [
     `worker ID ${result.workerId} · run ID ${result.runId}`,
     `status ${result.status} · generation ${result.generation}`,
@@ -341,7 +344,7 @@ function messageText(content: unknown): string {
   return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
 }
 
-function activeWorkers(snapshot: RuntimeSnapshot): WorkerRecord[] {
+function activeWorkers(snapshot: OwnerSnapshot): WorkerRecord[] {
   return snapshot.workers.filter((worker) => ACTIVE_STATUSES.has(worker.status));
 }
 

package/extension/pi/tool-renderer.ts

@@ -0,0 +1,422 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  getMarkdownTheme,
+  keyHint,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Markdown,
+  Spacer,
+  Text,
+  truncateToWidth,
+  wrapTextWithAnsi,
+  type Component,
+} from "@earendil-works/pi-tui";
+import { Result, Schema } from "effect";
+import {
+  disposeComponent,
+  formatElapsed,
+  resultAppearance,
+  WidthBoundComponent,
+} from "./tui.js";
+import {
+  decodeInlineWorkerToolDetails,
+  type InlineWorkerSettlementDetails,
+  WorkerSettlement,
+} from "../orchestration/settlement.js";
+
+const MAX_INSTRUCTION_PREVIEW_LINES = 2;
+
+const AcceptedRunRenderDetails = Schema.Struct({
+  mode: Schema.Literal("async"),
+  run_id: WorkerSettlement.fields.runId,
+  worker_id: WorkerSettlement.fields.workerId,
+});
+const UnavailableWorkerRenderDetails = Schema.Union([
+  Schema.Struct({ result: Schema.Unknown }),
+  Schema.Struct({ worker_id: Schema.Unknown }),
+]);
+const decodeAcceptedRunRenderDetails = Schema.decodeUnknownResult(
+  AcceptedRunRenderDetails,
+);
+const decodeUnavailableWorkerRenderDetails = Schema.decodeUnknownResult(
+  UnavailableWorkerRenderDetails,
+);
+
+interface RenderOptions {
+  readonly isPartial: boolean;
+  readonly expanded: boolean;
+}
+
+interface RenderContext {
+  readonly isError: boolean;
+  readonly lastComponent?: unknown;
+}
+
+export const orchestrateToolRenderer = {
+  renderCall(args: unknown, theme: Theme, { expanded }: RenderOptions) {
+    return renderDispatchCall(theme, args, expanded);
+  },
+  renderResult(
+    result: AgentToolResult<unknown>,
+    { isPartial, expanded }: RenderOptions,
+    theme: Theme,
+    context: RenderContext,
+  ) {
+    return renderOrchestrationResult(
+      result,
+      isPartial,
+      expanded,
+      theme,
+      context.isError,
+      context.lastComponent,
+    );
+  },
+};
+
+export const workerStatusToolRenderer = {
+  renderCall(_args: unknown, theme: Theme) {
+    return new Text(theme.fg("toolTitle", theme.bold("worker_status")), 0, 0);
+  },
+  renderResult(
+    result: AgentToolResult<unknown>,
+    { isPartial }: RenderOptions,
+    theme: Theme,
+    context: RenderContext,
+  ) {
+    return renderDiagnosticsResult(result, isPartial, context.isError, theme);
+  },
+};
+
+export const interactiveSendToolRenderer = {
+  renderCall(args: unknown, theme: Theme, { expanded }: RenderOptions) {
+    const fields = objectFields(args);
+    return renderInteractiveMessageCall(
+      theme,
+      "interactive_send",
+      fields.worker_id,
+      fields.instructions,
+      expanded,
+    );
+  },
+  renderResult: orchestrateToolRenderer.renderResult,
+};
+
+export const workerAbortToolRenderer = {
+  renderCall(args: unknown, theme: Theme) {
+    const fields = objectFields(args);
+    const workerIds = Array.isArray(fields.worker_ids)
+      ? fields.worker_ids
+      : undefined;
+    const target = workerIds
+      ? `${workerIds.length} worker${workerIds.length === 1 ? "" : "s"}`
+      : fields.all === true ? "all workers" : "";
+    return renderCompactCall(theme, "worker_abort", target);
+  },
+  renderResult(
+    result: AgentToolResult<unknown>,
+    { isPartial }: RenderOptions,
+    theme: Theme,
+    context: RenderContext,
+  ) {
+    return renderSimpleResult(
+      result,
+      context.isError,
+      isPartial ? "Requesting worker stop…" : "Worker stop requested",
+      theme,
+      "warning",
+    );
+  },
+};
+
+export const interactiveCloseToolRenderer = {
+  renderCall(args: unknown, theme: Theme) {
+    return renderCompactCall(
+      theme,
+      "interactive_close",
+      objectFields(args).worker_id,
+    );
+  },
+  renderResult(
+    result: AgentToolResult<unknown>,
+    { isPartial }: RenderOptions,
+    theme: Theme,
+    context: RenderContext,
+  ) {
+    return renderSimpleResult(
+      result,
+      context.isError,
+      isPartial ? "Closing worker…" : "✓ Worker closed",
+      theme,
+    );
+  },
+};
+
+function renderDispatchCall(
+  theme: Theme,
+  task: unknown,
+  expanded: boolean,
+): Component {
+  const fields = isRecord(task) ? task : {};
+  const container = new Container();
+  container.addChild(new Text(
+    theme.fg("toolTitle", theme.bold("orchestrate ")) + theme.fg("muted", safeTerminalText(fields.worker)),
+    0, 0,
+  ));
+  container.addChild(new Text(
+    `${theme.fg("accent", "→")} ${theme.fg("text", theme.bold(safeTerminalText(fields.title)))}`,
+    0, 0,
+  ));
+  if (expanded) {
+    container.addChild(new Text(safeTerminalText(fields.instructions), 2, 0));
+    return new WidthBoundComponent(container);
+  }
+  container.addChild(new InstructionPreview(fields.instructions, 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 instructions: unknown,
+    private readonly theme: Theme,
+  ) {}
+  render(width: number): string[] {
+    const bounded = Math.max(1, width);
+    const contentWidth = Math.max(1, bounded - 2);
+    const characterLimit = Math.max(256, Math.min(4096, contentWidth * 3));
+    const preview = compactInstructionPreview(this.instructions, characterLimit);
+    if (!preview.text) return [];
+
+    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, "…");
+    }
+    return previewLines.map((line) =>
+      truncateToWidth(this.theme.fg("dim", `  ${line}`), bounded, "…")
+    );
+  }
+  invalidate(): void {}
+}
+
+function renderInteractiveMessageCall(
+  theme: Theme,
+  tool: 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", 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));
+    container.addChild(new Text(theme.fg("dim", keyHint("app.tools.expand", "to inspect full message")), 0, 0));
+  }
+  return new WidthBoundComponent(container);
+}
+
+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 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: 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: unknown): Text {
+  return new Text(
+    theme.fg("toolTitle", theme.bold(`${tool} `)) + theme.fg("muted", safeTerminalText(target)),
+    0,
+    0,
+  );
+}
+
+function renderOrchestrationResult(
+  result: AgentToolResult<unknown>,
+  isPartial: boolean,
+  expanded: boolean,
+  theme: Theme,
+  isError: boolean,
+  lastComponent: unknown,
+): Component {
+  if (isError) {
+    return new WidthBoundComponent(renderSimpleResult(
+      result,
+      true,
+      firstResultLine(result) || "Worker operation failed",
+      theme,
+      "warning",
+    ));
+  }
+  const details = result.details;
+  if (Result.isSuccess(decodeAcceptedRunRenderDetails(details))) {
+    return new WidthBoundComponent(new Text(theme.fg("success", "Sent to worker") + theme.fg("dim", " · response arrives when complete"), 0, 0));
+  }
+  const inlineResult = readInlineResult(details);
+  if (inlineResult) {
+    const component = lastComponent instanceof InlineResultComponent
+      ? lastComponent
+      : new InlineResultComponent(theme);
+    component.update(inlineResult, isPartial, expanded);
+    return component;
+  }
+  if (Result.isSuccess(decodeUnavailableWorkerRenderDetails(details))) {
+    return new WidthBoundComponent(new Text(theme.fg("warning", "Worker result details unavailable"), 0, 0));
+  }
+  if (isPartial) return new WidthBoundComponent(new Text(theme.fg("warning", "Sending work…"), 0, 0));
+  return new WidthBoundComponent(renderSimpleResult(
+    result,
+    false,
+    firstResultLine(result) || "Work sent",
+    theme,
+    "warning",
+  ));
+}
+
+interface RenderedInlineSettlement {
+  worker: string;
+  title: string;
+  status: InlineWorkerSettlementDetails["status"];
+  response: string;
+  elapsed?: string;
+}
+
+class InlineResultComponent implements Component {
+  private result: RenderedInlineSettlement | undefined;
+  private partial = false;
+  private expanded = false;
+  private child: Component = new Container();
+  constructor(private readonly theme: Theme) {}
+  update(result: RenderedInlineSettlement, partial: boolean, expanded: boolean): void {
+    this.result = result;
+    this.partial = partial;
+    this.expanded = expanded;
+    this.rebuild();
+  }
+  render(width: number): string[] { return new WidthBoundComponent(this.child).render(width); }
+  invalidate(): void { this.rebuild(); }
+  dispose(): void { disposeComponent(this.child); }
+  private rebuild(): void {
+    disposeComponent(this.child);
+    const container = new Container();
+    const result = this.result;
+    if (!result) {
+      this.child = container;
+      return;
+    }
+    const appearance = resultAppearance(result.status, "ready for follow-up");
+    const suffix = [appearance.qualifier, result.elapsed].filter(Boolean).join(" · ");
+    const title = this.theme.bold(result.title);
+    const workerName = this.theme.fg("muted", this.theme.italic(result.worker));
+    const header = [
+      this.theme.fg(appearance.color, `${appearance.icon} ${title}`),
+      workerName,
+      ...(suffix ? [this.theme.fg(appearance.color, suffix)] : []),
+    ].join(" · ");
+    container.addChild(new WidthBoundComponent(new Text(header, 0, 0), 1));
+    if (result.response) {
+      const markdown = new Markdown(result.response, this.expanded ? 2 : 0, 0, getMarkdownTheme());
+      container.addChild(new WidthBoundComponent(markdown, this.expanded ? undefined : 2));
+    }
+    container.addChild(new Spacer(1));
+    if (this.partial) container.addChild(new Text(this.theme.fg("warning", "Receiving worker response…"), 0, 0));
+    else if (!this.expanded) container.addChild(new Text(this.theme.fg("dim", keyHint("app.tools.expand", "to inspect full response")), 0, 0));
+    this.child = container;
+  }
+}
+
+function readInlineResult(details: unknown): RenderedInlineSettlement | undefined {
+  const decoded = decodeInlineWorkerToolDetails(details);
+  if (Result.isFailure(decoded)) return undefined;
+  const settlement = decoded.success.result;
+  const outcome = settlement.outcome;
+  const message = outcome.status === "failed" || outcome.status === "aborted"
+    ? outcome.message
+    : undefined;
+  const assistantText = outcome.assistantText;
+  const response = [message, assistantText]
+    .filter((item): item is string => typeof item === "string" && item.length > 0)
+    .join("\n\n");
+  return {
+    worker: settlement.worker,
+    title: settlement.title,
+    status: settlement.status,
+    response,
+    elapsed: formatElapsed(settlement.settledAt - settlement.startedAt),
+  };
+}
+
+function renderDiagnosticsResult(
+  result: AgentToolResult<unknown>,
+  isPartial: boolean,
+  isError: boolean,
+  theme: Theme,
+): Text {
+  if (isError) {
+    return renderSimpleResult(
+      result,
+      true,
+      firstResultLine(result) || "Worker diagnostics failed",
+      theme,
+    );
+  }
+  if (isPartial) return new Text(theme.fg("muted", "Reading worker diagnostics…"), 0, 0);
+  const details = result.details;
+  if (isRecord(details) && isRecord(details.state) && Array.isArray(details.state.workers)) {
+    const workers = details.state.workers.filter(isRecord);
+    const active = workers.filter((worker) => ["starting", "running", "stopping"].includes(String(worker.status))).length;
+    const ready = workers.filter((worker) => worker.status === "ready").length;
+    const diagnostics = isRecord(details.catalog) && Array.isArray(details.catalog.diagnostics) ? details.catalog.diagnostics.length : 0;
+    const facts = [active ? `${active} active` : "No active workers", ready ? `${ready} available for follow-up` : undefined, diagnostics ? `${diagnostics} catalog diagnostic${diagnostics === 1 ? "" : "s"}` : undefined].filter(Boolean);
+    return new Text(theme.fg("muted", facts.join(" · ")), 0, 0);
+  }
+  return new Text(theme.fg("muted", firstResultLine(result) || "Diagnostics unavailable"), 0, 0);
+}
+
+function renderSimpleResult(
+  result: AgentToolResult<unknown>,
+  isError: boolean,
+  message: string,
+  theme: Theme,
+  normalColor: "success" | "warning" = "success",
+): Text {
+  const text = isError ? firstResultLine(result) || message : message;
+  return new Text(theme.fg(isError ? "error" : normalColor, text), 0, 0);
+}
+
+function firstResultLine(result: AgentToolResult<unknown>): string | undefined {
+  const first = result.content[0];
+  if (first?.type !== "text") return undefined;
+  return first.text.split("\n").find((line) => line.trim())?.trim();
+}
+
+function objectFields(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}