@zachwill/pi-orchestrate 0.2.1 → 0.4.0

package/extension/presentation.ts

@@ -14,10 +14,14 @@ import {
   visibleWidth,
   type Component,
 } from "@earendil-works/pi-tui";
-import { Result, Schema } from "effect";
+import { Result } from "effect";
 import type { WorkerDeliveryDetails } from "./delivery.js";
-import type { WorkerOutcome, WorkerRecord, WorkerStatus, WorkerUsage } from "./domain.js";
+import type { WorkerOutcome, WorkerRecord, WorkerStatus } from "./domain.js";
 import type { OrchestratorRuntime, RuntimeSnapshot } from "./runtime.js";
+import {
+  decodePersistedWorkerSettlementDetails,
+  type WorkerSettlementDetails,
+} from "./worker-settlement.js";
 
 export const ORCHESTRATION_PRESENTATION_KEY = "pi-orchestrate";
 export const MAX_RESULT_PREVIEW_LINES = 6;
@@ -43,77 +47,7 @@ const ACTIVE_STATUSES: ReadonlySet<WorkerStatus> = new Set(["starting", "running
 
 export type PresentationRuntime = Pick<OrchestratorRuntime, "snapshot" | "subscribeState">;
 
-const NonnegativeFinite = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
-const NonnegativeInteger = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const legacyOptionalKey = <S extends Schema.Constraint>(schema: S) =>
-  Schema.optionalKey(Schema.UndefinedOr(schema));
-
-const WorkerUsageSchema = Schema.Struct({
-  input: NonnegativeFinite,
-  output: NonnegativeFinite,
-  cacheRead: NonnegativeFinite,
-  cacheWrite: NonnegativeFinite,
-  cost: NonnegativeFinite,
-  contextTokens: NonnegativeFinite,
-  turns: NonnegativeInteger,
-});
-
-const WorkerCompletedOutcomeSchema = Schema.Struct({
-  status: Schema.Literal("completed"),
-  assistantText: Schema.String,
-});
-const WorkerReadyOutcomeSchema = Schema.Struct({
-  status: Schema.Literal("ready"),
-  assistantText: Schema.String,
-});
-const WorkerFailedOutcomeSchema = Schema.Struct({
-  status: Schema.Literal("failed"),
-  message: Schema.String,
-  assistantText: legacyOptionalKey(Schema.String),
-});
-const WorkerAbortedOutcomeSchema = Schema.Struct({
-  status: Schema.Literal("aborted"),
-  message: legacyOptionalKey(Schema.String),
-  assistantText: legacyOptionalKey(Schema.String),
-});
-const WorkerOutcomeSchema = Schema.Union([
-  WorkerCompletedOutcomeSchema,
-  WorkerReadyOutcomeSchema,
-  WorkerFailedOutcomeSchema,
-  WorkerAbortedOutcomeSchema,
-]);
-
-const SettlementPayloadSchema = Schema.Struct({
-  eventId: legacyOptionalKey(Schema.String),
-  sequence: legacyOptionalKey(NonnegativeInteger),
-  ownerSessionId: Schema.String,
-  waveId: Schema.String,
-  workerId: Schema.String,
-  generation: NonnegativeInteger,
-  mode: Schema.Literals(["async", "inline"]),
-  worker: Schema.String,
-  title: Schema.String,
-  lifecycle: Schema.Literals(["one-shot", "reusable"]),
-  status: Schema.Literals(["completed", "ready", "failed", "aborted"]),
-  outcome: WorkerOutcomeSchema,
-  usage: WorkerUsageSchema,
-  startedAt: NonnegativeInteger,
-  settledAt: NonnegativeInteger,
-  remainingActive: legacyOptionalKey(NonnegativeInteger),
-  waveComplete: legacyOptionalKey(Schema.Boolean),
-  sessionFile: legacyOptionalKey(Schema.String),
-  failureStage: legacyOptionalKey(Schema.Literals(["startup", "prompt", "workflow", "cancellation"])),
-}).check(Schema.makeFilter((settlement) => {
-  if (settlement.outcome.status !== settlement.status) return "outcome status must match settlement status";
-  if (settlement.settledAt < settlement.startedAt) return "settlement timestamp must not precede start timestamp";
-  if (settlement.failureStage !== undefined && settlement.status !== "failed" && settlement.status !== "aborted") {
-    return "failure stage requires a failed or aborted settlement";
-  }
-}));
-
-const SettlementEnvelopeSchema = Schema.Struct({ settlement: SettlementPayloadSchema });
-const decodeSettlementEnvelope = Schema.decodeUnknownResult(SettlementEnvelopeSchema);
-type SafeSettlement = Schema.Schema.Type<typeof SettlementPayloadSchema>;
+type SafeSettlement = WorkerSettlementDetails;
 
 interface StatusBinding {
   readonly ownerSessionId: string;
@@ -130,40 +64,6 @@ export function registerOrchestrationPresentation(pi: ExtensionAPI): void {
   );
 }
 
-export function formatResultStatusSummary(details: unknown): string {
-  const result = readSettlement(details);
-  return result ? statusHeading(result) : "Worker result details unavailable";
-}
-
-export function formatResultPreviews(
-  details: unknown,
-  fallbackContent = "",
-  limit = MAX_RESULT_PREVIEW_LINES,
-): string[] {
-  if (limit <= 0) return [];
-  const result = readSettlement(details);
-  const body = result ? outcomeText(result.outcome) : fallbackContent;
-  return firstNonEmptyLines(body, limit);
-}
-
-export function formatWorkerUsage(usage: Partial<WorkerUsage> | undefined): string | undefined {
-  if (!usage) return undefined;
-  const parts = [
-    `${numberOrZero(usage.turns)}t`,
-    `${formatCompactNumber(numberOrZero(usage.contextTokens))} ctx`,
-    `↑${formatCompactNumber(numberOrZero(usage.input))}`,
-    `↓${formatCompactNumber(numberOrZero(usage.output))}`,
-    `R${formatCompactNumber(numberOrZero(usage.cacheRead))}`,
-    `W${formatCompactNumber(numberOrZero(usage.cacheWrite))}`,
-    `$${numberOrZero(usage.cost).toFixed(4)}`,
-  ];
-  return parts.join(" · ");
-}
-
-export function formatWorkerStatusLine(worker: WorkerRecord): string {
-  return `${worker.worker} → ${worker.title} · ${workerStateLabel(worker)} · ${formatTurnMarker(worker)} · ${formatCompactNumber(numberOrZero(worker.usage?.contextTokens))} ctx`;
-}
-
 export function formatFooterStatus(snapshot: RuntimeSnapshot): string | undefined {
   const ready = snapshot.workers.filter((worker) => worker.status === "ready").length;
   return ready > 0 ? `${ready} available for follow-up` : undefined;
@@ -308,24 +208,29 @@ export class WorkerStatusComponent implements Component {
   }
 
   private workerLine(worker: WorkerRecord, width: number): string {
-    const animation = worker.status === "starting"
-      ? WORKER_ANIMATIONS.starting
-      : worker.status === "stopping"
-        ? WORKER_ANIMATIONS.stopping
-        : WORKER_ANIMATIONS.running;
+    const animation = workerAnimation(worker.status);
     const glyph = this.theme.fg(
       animation.color,
       animation.frames[this.frameIndex % animation.frames.length] ?? animation.frames[0],
     );
     const turns = formatTurnMarker(worker);
     const context = `${formatContextTokens(numberOrZero(worker.usage?.contextTokens))} ctx`;
-    const suffixFields = width >= 28 ? [turns, context] : width >= 12 ? [turns] : [];
-    const requiredWidth = (fields: readonly string[]) => visibleWidth(`⠋  · ${fields.join(" · ")}`) + 10;
-    const showWorker = width >= 72 && requiredWidth([worker.worker, ...suffixFields]) <= width;
-    const prefix = showWorker ? `${glyph} ${this.theme.fg("muted", worker.worker)} → ` : `${glyph} `;
+    const usageFields = width >= 28 ? [turns, context] : width >= 12 ? [turns] : [];
+    const workerType = this.theme.fg("muted", this.theme.italic(worker.worker));
+    const workerTypeFits = visibleWidth(
+      `⠋  · ${worker.worker} · ${usageFields.join(" · ")}`,
+    ) + 10 <= width;
+    const suffixFields = width >= 72 && workerTypeFits
+      ? [workerType, ...usageFields]
+      : usageFields;
+    const prefix = `${glyph} `;
     const suffix = suffixFields.length ? ` · ${suffixFields.join(" · ")}` : "";
     const titleWidth = Math.max(1, width - visibleWidth(prefix) - visibleWidth(suffix));
-    const title = truncateToWidth(this.theme.fg("text", this.theme.bold(worker.title)), titleWidth, "…");
+    const title = truncateToWidth(
+      this.theme.fg("text", this.theme.bold(worker.title)),
+      titleWidth,
+      "…",
+    );
     return `${prefix}${title}${suffix}`;
   }
 }
@@ -371,24 +276,23 @@ export class WorkerResultComponent implements Component {
       return box;
     }
 
-    const color = details.status === "failed" ? "error" : details.status === "aborted" ? "warning" : "success";
+    const color = resultColor(details.status);
     const elapsed = elapsedBetween(details.startedAt, details.settledAt);
-    const status = details.status === "aborted"
-      ? " · aborted"
-      : details.status === "failed" && details.failureStage === "startup"
-        ? " · could not start"
-        : "";
-    const header = `${statusIcon(details)} ${details.worker} · ${details.title}${status}${elapsed ? ` · ${elapsed}` : ""}`;
+    const qualifier = resultQualifier(details);
+    const title = this.theme.bold(details.title);
+    const workerType = this.theme.fg("muted", this.theme.italic(details.worker));
+    const suffix = [qualifier, elapsed].filter(Boolean).join(" · ");
+    const header = [
+      this.theme.fg(color, `${statusIcon(details)} ${title}`),
+      workerType,
+      ...(suffix ? [this.theme.fg(color, suffix)] : []),
+    ].join(" · ");
     const outcome = presentedOutcome(details);
-    box.addChild(new Text(this.theme.fg(color, this.theme.bold(header)), 0, 0));
-    box.addChild(new Spacer(1));
-    if (outcome.heading) {
-      box.addChild(new Text(this.theme.fg("success", this.theme.bold(outcome.heading)), 0, 0));
-      if (outcome.body) box.addChild(new Spacer(1));
-    }
-    if (outcome.body) {
+    box.addChild(new Text(header, 0, 0));
+    if (outcome) {
+      box.addChild(new Spacer(1));
       box.addChild(new WidthBoundComponent(
-        new Markdown(outcome.body, 0, 0, getMarkdownTheme()),
+        new Markdown(outcome, 0, 0, getMarkdownTheme()),
         this.expanded ? undefined : MAX_RESULT_PREVIEW_LINES,
       ));
     }
@@ -405,16 +309,30 @@ export class WorkerResultComponent implements Component {
 }
 
 function readSettlement(value: unknown): SafeSettlement | undefined {
-  const envelope = isRecord(value) && isRecord(value.settlement) ? value : { settlement: value };
-  const decoded = decodeSettlementEnvelope(envelope);
-  return Result.isSuccess(decoded) ? decoded.success.settlement : undefined;
+  const decoded = decodePersistedWorkerSettlementDetails(value);
+  return Result.isSuccess(decoded) ? decoded.success : undefined;
+}
+
+function workerAnimation(status: WorkerStatus) {
+  if (status === "starting") return WORKER_ANIMATIONS.starting;
+  if (status === "stopping") return WORKER_ANIMATIONS.stopping;
+  return WORKER_ANIMATIONS.running;
 }
 
-function statusHeading(result: SafeSettlement): string {
-  if (result.status === "failed") return result.failureStage === "startup" ? "could not start" : "failed";
+function resultColor(status: SafeSettlement["status"]): "success" | "error" | "warning" {
+  if (status === "failed") return "error";
+  if (status === "aborted") return "warning";
+  return "success";
+}
+
+function resultQualifier(result: SafeSettlement): string | undefined {
   if (result.status === "aborted") return "aborted";
-  if (result.status === "ready") return "response complete";
-  return "completed";
+  if (result.status === "failed" && result.failureStage === "startup") {
+    return "could not start";
+  }
+  if (result.status === "failed") return "failed";
+  if (result.status === "ready") return "ready for follow-up";
+  return undefined;
 }
 
 function statusIcon(result: SafeSettlement): string {
@@ -430,27 +348,24 @@ function outcomeText(outcome: WorkerOutcome): string {
   return "Worker session closed.";
 }
 
-function presentedOutcome(result: SafeSettlement): { heading?: string; body: string } {
+function presentedOutcome(result: SafeSettlement): string {
   const body = outcomeText(result.outcome);
-  if (result.status !== "completed" && result.status !== "ready") return { body };
+  if (result.status !== "completed" && result.status !== "ready") return body;
 
   const lines = body.split("\n");
   const headingIndex = lines.findIndex((line) => line.trim() !== "");
   if (headingIndex < 0 || !/^#{1,6}\s+(?:completed|complete|done)\s*#*\s*$/i.test(lines[headingIndex]!)) {
-    return { body };
+    return body;
   }
 
   lines.splice(headingIndex, 1);
   while (lines[headingIndex]?.trim() === "") lines.splice(headingIndex, 1);
-  return {
-    heading: result.status === "ready" ? "✓ Response complete" : "✓ Completed",
-    body: lines.join("\n").trimEnd(),
-  };
+  return lines.join("\n").trimEnd();
 }
 
 function settlementMetadata(result: SafeSettlement): string[] {
   return [
-    `worker ID ${result.workerId} · wave ID ${result.waveId}`,
+    `worker ID ${result.workerId} · run ID ${result.runId}`,
     `status ${result.status} · generation ${result.generation}`,
     `turns ${numberOrZero(result.usage.turns)} · current context ${formatCompactNumber(numberOrZero(result.usage.contextTokens))}`,
     `input ${numberOrZero(result.usage.input)} · output ${numberOrZero(result.usage.output)} · cache read ${numberOrZero(result.usage.cacheRead)} · cache write ${numberOrZero(result.usage.cacheWrite)} · cost $${numberOrZero(result.usage.cost).toFixed(4)}`,
@@ -468,14 +383,6 @@ function activeWorkers(snapshot: RuntimeSnapshot): WorkerRecord[] {
   return snapshot.workers.filter((worker) => ACTIVE_STATUSES.has(worker.status));
 }
 
-const TOOL_ACTIVITY: Readonly<Record<string, string>> = { read: "reading", grep: "searching", find: "finding files", ls: "listing", bash: "running command", edit: "editing", write: "writing" };
-function workerStateLabel(worker: Pick<WorkerRecord, "status" | "activity">): string {
-  if (worker.status === "starting" || worker.status === "stopping") return worker.status;
-  if (worker.status !== "running") return worker.status;
-  if (!worker.activity?.trim()) return "working";
-  return TOOL_ACTIVITY[worker.activity] ?? worker.activity;
-}
-
 function formatTurnMarker(worker: Pick<WorkerRecord, "messageDirection" | "usage">): string {
   const direction = worker.messageDirection === "from-model" ? "↓" : "↑";
   return `${numberOrZero(worker.usage?.turns)}${direction}`;
@@ -489,9 +396,6 @@ function formatElapsed(milliseconds: number): string {
   const minutes = Math.floor(seconds / 60);
   return seconds % 60 === 0 ? `${minutes}m` : `${minutes}m ${seconds % 60}s`;
 }
-function firstNonEmptyLines(text: string, limit: number): string[] {
-  return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, limit);
-}
 function numberOrZero(value: unknown): number { return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0; }
 function formatContextTokens(value: number): string {
   if (value < 1_000) return String(Math.round(value));