@osolmaz/pi-workflows 0.15.3 → 0.16.0

package/src/extension/session-view.ts

@@ -1,32 +1,51 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { SqliteControllerStore } from "../controllers/sqlite.js";
-import { workflowStatePath } from "../state/database.js";
-import { WorkflowRunStore, type LoadedWorkflowRun } from "../workflows/store.js";
+import type { WorkflowSessionView } from "../client/view.js";
+import type { WorkflowDefinitionSnapshot, WorkflowRunState } from "../workflows/types.js";
 import { buildWidgetView } from "./widget.js";
 
 const WIDGET_KEY = "pi-workflows";
 const WIDGET_SCROLL_STEP = 3;
 
-/** Read-only projection of the host-owned run into the origin Pi session. */
+/** Client-backed projection of the host-owned run into the origin Pi session. */
 export class SessionWorkflowView {
-  private loaded: LoadedWorkflowRun | undefined;
+  private session: WorkflowSessionView | null = null;
   private scroll: number | null = null;
   private shownScroll = 0;
   private maxScroll = 0;
   private stepCount = 0;
   private visible = false;
+  private actionHint: string | undefined;
 
-  refresh(ctx: ExtensionContext): void {
-    const loaded = loadSessionRun(ctx.sessionManager.getSessionId());
-    if (loaded === undefined) {
-      this.clear(ctx);
+  update(session: WorkflowSessionView, ctx: ExtensionContext): void {
+    const run = session.run;
+    if (
+      run === null ||
+      !isWorkflowRunState(run.state) ||
+      !isWorkflowDefinitionSnapshot(run.workflow)
+    ) {
+      this.session = session;
+      this.clearWidget(ctx);
       return;
     }
-    if (this.loaded?.runId !== loaded.runId || this.stepCount !== loaded.state.steps.length) {
+    const previousRun = this.session?.run;
+    if (previousRun?.runId !== run.runId || this.stepCount !== run.state.steps.length) {
       this.scroll = null;
-      this.stepCount = loaded.state.steps.length;
+      this.stepCount = run.state.steps.length;
+    }
+    this.session = session;
+    this.render(ctx);
+  }
+
+  setActionHint(hint: string | undefined, ctx: ExtensionContext): void {
+    this.actionHint = hint;
+    if (this.session?.run !== null) this.render(ctx);
+  }
+
+  refresh(ctx: ExtensionContext): void {
+    if (this.session?.run === null || this.session === null) {
+      this.clearWidget(ctx);
+      return;
     }
-    this.loaded = loaded;
     this.render(ctx);
   }
 
@@ -39,42 +58,51 @@ export class SessionWorkflowView {
   }
 
   clear(ctx: ExtensionContext): void {
-    this.loaded = undefined;
+    this.session = null;
     this.scroll = null;
     this.shownScroll = 0;
     this.maxScroll = 0;
     this.stepCount = 0;
-    if (!this.visible) return;
-    this.visible = false;
-    safelyUpdateUi(ctx, () => {
-      ctx.ui.setWidget(WIDGET_KEY, undefined);
-      ctx.ui.setStatus(WIDGET_KEY, undefined);
-    });
+    this.clearWidget(ctx);
   }
 
   private scrollBy(ctx: ExtensionContext, delta: number): void {
-    if (this.loaded === undefined) return;
+    if (this.session?.run === null || this.session === null) return;
     const current = this.scroll ?? this.shownScroll;
     this.scroll = Math.max(0, Math.min(this.maxScroll, current + delta));
     this.render(ctx);
   }
 
+  private clearWidget(ctx: ExtensionContext): void {
+    if (!this.visible) return;
+    this.visible = false;
+    safelyUpdateUi(ctx, () => {
+      ctx.ui.setWidget(WIDGET_KEY, undefined);
+      ctx.ui.setStatus(WIDGET_KEY, undefined);
+    });
+  }
+
   private render(ctx: ExtensionContext): void {
-    const loaded = this.loaded;
-    if (loaded === undefined) return;
+    const run = this.session?.run;
+    if (run === null || run === undefined) return;
+    if (!isWorkflowRunState(run.state) || !isWorkflowDefinitionSnapshot(run.workflow)) return;
+    const state = run.state;
+    const snapshot = run.workflow;
     const render = (
       width = Number.POSITIVE_INFINITY,
       theme?: Parameters<typeof buildWidgetView>[6],
     ) => {
       const view = buildWidgetView(
-        loaded.state,
-        loaded.snapshot,
+        state,
+        snapshot,
         new Date(),
         this.scroll,
-        loaded.state.paused === true,
+        run.display.status === "paused",
         width,
         theme,
         undefined,
+        this.actionHint,
+        run.display.status,
       );
       this.shownScroll = view.scroll;
       this.maxScroll = view.maxScroll;
@@ -90,42 +118,37 @@ export class SessionWorkflowView {
       } else {
         ctx.ui.setWidget(WIDGET_KEY, render());
       }
-      const label = loaded.state.paused === true ? "paused" : loaded.state.status;
-      ctx.ui.setStatus(WIDGET_KEY, `${loaded.state.workflowName} [${label}]`);
+      ctx.ui.setStatus(WIDGET_KEY, `${state.workflowName} [${run.display.status}]`);
       this.visible = true;
     });
   }
 }
 
-function loadSessionRun(sessionId: string): LoadedWorkflowRun | undefined {
-  try {
-    const queue = new SqliteControllerStore(workflowStatePath(), {
-      readOnly: true,
-      global: true,
-    });
-    let runId: string | undefined;
-    try {
-      runId = queue.findSessionReservation(sessionId)?.runId;
-    } finally {
-      queue.close();
-    }
-    if (runId === undefined) return undefined;
+function isWorkflowRunState(value: unknown): value is WorkflowRunState {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (value as { schema?: unknown }).schema === "pi-workflows.run-state.v1" &&
+    typeof (value as { workflowName?: unknown }).workflowName === "string" &&
+    Array.isArray((value as { steps?: unknown }).steps)
+  );
+}
 
-    const runs = new WorkflowRunStore(workflowStatePath(), { readOnly: true });
-    try {
-      return runs.readRun(runId) ?? undefined;
-    } finally {
-      runs.close();
-    }
-  } catch {
-    return undefined;
-  }
+function isWorkflowDefinitionSnapshot(value: unknown): value is WorkflowDefinitionSnapshot {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (value as { schema?: unknown }).schema === "pi-workflows.definition-snapshot.v1" &&
+    typeof (value as { nodes?: unknown }).nodes === "object"
+  );
 }
 
 function safelyUpdateUi(ctx: ExtensionContext, update: () => void): void {
   try {
     if (ctx.hasUI) update();
   } catch {
-    // A session replacement can make a captured context stale between polls.
+    // A session replacement can make a captured context stale between updates.
   }
 }

package/src/extension/widget.ts

@@ -1,5 +1,6 @@
 import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { WorkflowDisplayStatus } from "../client/view.js";
 import { formatDuration } from "../render/format.js";
 import { nodeTypeGlyph } from "../render/node-type.js";
 import {
@@ -14,17 +15,19 @@ import { sanitizeText } from "../workflows/text.js";
 import type {
   WorkflowDefinitionSnapshot,
   WorkflowRunState,
-  WorkflowRunStatus,
   WorkflowUpdateRecord,
 } from "../workflows/types.js";
 
-const STATUS_GLYPHS: Record<WorkflowRunStatus, string> = {
+const STATUS_GLYPHS: Record<WorkflowDisplayStatus, string> = {
+  queued: "…",
   running: "◐",
-  waiting: "⏸",
+  waiting: "○",
+  paused: "⏸",
   completed: "✓",
   failed: "✗",
   timed_out: "✗",
   cancelled: "✗",
+  ambiguous: "!",
 };
 
 /**
@@ -79,26 +82,28 @@ export function buildWidgetView(
   theme?: WidgetTheme,
   updateHistory?: WorkflowUpdateRecord[],
   actionHint?: string,
+  displayStatus?: WorkflowDisplayStatus,
 ): WidgetView {
   const availableWidth = Number.isFinite(width) ? Math.max(0, Math.floor(width)) : width;
   if (availableWidth === 0) return { lines: [], scroll: 0, maxScroll: 0 };
 
   // `held` covers pauses the state cannot see yet: an escape-interrupted
   // step or a pause requested while the current node is still finishing.
-  const paused = held || state.paused === true;
-  const glyph = paused ? "⏸" : (STATUS_GLYPHS[state.status] ?? "·");
-  const statusText = paused ? "paused" : state.status;
+  const status = displayStatus ?? (held || state.paused === true ? "paused" : state.status);
+  const paused = status === "paused";
+  const glyph = STATUS_GLYPHS[status];
+  const statusText = status;
   // Titles, status details, and errors can carry model- or shell-controlled
   // text; never let escape sequences or newlines reach the terminal.
   const title = state.runTitle ? ` — ${sanitizeText(state.runTitle)}` : "";
-  const headerTone = statusTone(paused ? "waiting" : state.status);
+  const headerTone = statusTone(status);
   const header = `${paint(theme, headerTone, glyph)} workflow ${sanitizeText(state.workflowName)}${title} ${paint(theme, headerTone, `[${statusText}]`)}`;
 
   const footer: string[] = [];
   if (state.error) {
     footer.push(paint(theme, "error", `  error: ${truncate(sanitizeText(state.error), 120)}`));
   }
-  if (state.status === "waiting" && state.waitingOn) {
+  if (status === "waiting" && state.waitingOn) {
     footer.push(
       paint(theme, "warning", `  waiting on checkpoint: ${sanitizeText(state.waitingOn)}`),
     );
@@ -407,7 +412,10 @@ function statusTone(status: string): ThemeColor {
     case "cancelled":
       return "error";
     case "waiting":
+    case "paused":
       return "warning";
+    case "ambiguous":
+      return "error";
     case "running":
     default:
       return "accent";

package/src/host/child-worker-supervisor.ts

@@ -1,8 +1,8 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { once } from "node:events";
+import { NdjsonFrameDecoder } from "../client/protocol.js";
 import { errorMessage } from "../workflows/errors.js";
 import { HostProcessRegistry, type ProcessIdentity } from "./processes.js";
-import { NdjsonFrameDecoder } from "./protocol.js";
 import type { WorkerOutcome } from "./state.js";
 
 const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;

package/src/host/resolver-entry.ts

@@ -3,6 +3,12 @@ import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { builtinWorkflowCatalog } from "../builtins/catalog.js";
+import { MAX_PROTOCOL_MESSAGE_BYTES } from "../client/protocol.js";
+import type {
+  ResolvedControllerInitialization,
+  ResolvedSettingsChange,
+  ResolvedWorkflowLaunch,
+} from "../client/resolver.js";
 import { discoverControllers, loadControllerFile } from "../controllers/loader.js";
 import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
 import { compositionMetadata } from "../workflows/composition.js";
@@ -12,32 +18,11 @@ import { resolveWorkflowRef } from "../workflows/loader.js";
 import { applyWorkflowSettingsPatch } from "../workflows/settings.js";
 import { createDefinitionSnapshot } from "../workflows/store.js";
 import type { WorkflowDefinition, WorkflowSource } from "../workflows/types.js";
-import { MAX_PROTOCOL_MESSAGE_BYTES } from "./protocol.js";
-
-export type ResolvedWorkflowLaunch = {
-  schema: "pi-workflows.resolved-launch.v1";
-  workflowName: string;
-  workflowSourceRef: string;
-  workflowSource: JsonValue;
-  definitionDigest: string;
-  definitionSnapshot: JsonValue;
-};
-
-export type ResolvedControllerInitialization = {
-  schema: "pi-workflows.resolved-controller-initialization.v1";
-  controllerName: string;
-  controllerPath: string;
-  sourceHash: string;
-  initialStatus: JsonValue;
-};
-
-export type ResolvedSettingsChange = {
-  schema: "pi-workflows.resolved-settings-change.v1";
-  definitionDigest: string;
-  patch: JsonValue;
-  settings: JsonValue;
-  paths: JsonValue;
-};
+export type {
+  ResolvedControllerInitialization,
+  ResolvedSettingsChange,
+  ResolvedWorkflowLaunch,
+} from "../client/resolver.js";
 
 type ResolverRequest = {
   schema: "pi-workflows.resolve-request.v1";