@osolmaz/pi-workflows 0.16.2 → 0.16.3

package/src/server/workflow-runner-supervisor.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { canonicalJson } from "../state/json.js";
+import { ChildRunnerSupervisor, type SupervisedRunnerResult } from "./child-runner-supervisor.js";
+import { ServerProcessRegistry, type ProcessIdentity } from "./processes.js";
+import type { WorkflowRunnerLaunchEnvelope, RunnerOutcome } from "./state.js";
+import {
+  MAX_WORKFLOW_RUNNER_PROTOCOL_MESSAGE_BYTES,
+  encodeRunnerLine,
+  parseRunnerMessage,
+  type WorkflowRunnerMessage,
+  type WorkflowRunnerResponse,
+} from "./workflow-runner-protocol.js";
+
+export type WorkflowRunnerResult = SupervisedRunnerResult;
+
+export class WorkflowRunnerSupervisor {
+  private readonly supervisor: ChildRunnerSupervisor<WorkflowRunnerMessage, WorkflowRunnerResponse>;
+
+  constructor(
+    readonly envelope: WorkflowRunnerLaunchEnvelope,
+    private readonly options: {
+      registry: ServerProcessRegistry;
+      onMessage: (message: WorkflowRunnerMessage) => Promise<WorkflowRunnerResponse>;
+      env?: Record<string, string>;
+      startupTimeoutMs?: number;
+      runnerEntryPath?: string;
+      onSpawn?: (identity: ProcessIdentity) => void;
+      onDiagnostic?: (message: string) => void;
+    },
+  ) {
+    this.supervisor = new ChildRunnerSupervisor({
+      label: "Workflow runner",
+      registry: options.registry,
+      onMessage: options.onMessage,
+      parseMessage: parseRunnerMessage,
+      encodeResponse: encodeRunnerLine,
+      isReady: (message) => message.kind === "runner.ready",
+      isTerminal: (message) => message.kind === "runner.exiting",
+      maxMessageBytes: MAX_WORKFLOW_RUNNER_PROTOCOL_MESSAGE_BYTES,
+      oversizedMessage: "Runner protocol message exceeds 1 MiB",
+      ...(options.startupTimeoutMs === undefined
+        ? {}
+        : { startupTimeoutMs: options.startupTimeoutMs }),
+      ...(options.onSpawn === undefined ? {} : { onSpawn: options.onSpawn }),
+      ...(options.onDiagnostic === undefined ? {} : { onDiagnostic: options.onDiagnostic }),
+    });
+  }
+
+  async start(): Promise<void> {
+    const builtEntry = fileURLToPath(new URL("./workflow-runner-entry.js", import.meta.url));
+    const sourceEntry = fileURLToPath(new URL("./workflow-runner-entry.ts", import.meta.url));
+    const runnerEntry = this.options.runnerEntryPath ?? builtEntry;
+    const args =
+      this.options.runnerEntryPath === undefined && !fs.existsSync(builtEntry)
+        ? ["--import", createRequire(import.meta.url).resolve("tsx"), sourceEntry]
+        : [runnerEntry];
+    await this.supervisor.start({
+      args,
+      cwd: this.envelope.projectPath,
+      env: {
+        ...process.env,
+        ...this.options.env,
+        PI_WORKFLOWS_WORKFLOW_RUNNER_LAUNCH: Buffer.from(canonicalJson(this.envelope)).toString(
+          "base64url",
+        ),
+      },
+    });
+  }
+
+  async wait(): Promise<WorkflowRunnerResult> {
+    return await this.supervisor.wait();
+  }
+
+  async stop(outcome: RunnerOutcome = "cancelled"): Promise<void> {
+    await this.supervisor.stop(outcome);
+  }
+}

package/src/state/prune.ts

@@ -48,6 +48,7 @@ export async function pruneState(
   state: StateDatabase,
   databasePath: string,
   options: StatePruneOptions,
+  activeBlobHashes: () => readonly Buffer[] = () => [],
 ): Promise<StatePruneReport> {
   validateStatePruneOptions(options);
   const cutoff = parseCutoff(options.before);
@@ -114,8 +115,9 @@ export async function pruneState(
            )`,
         )
         .run();
-      const blobStats = unreferencedBlobStats(state.connection);
-      deleteUnreferencedBlobs(state.connection);
+      const retainedBlobHashes = activeBlobHashes();
+      const blobStats = unreferencedBlobStats(state.connection, retainedBlobHashes);
+      deleteUnreferencedBlobs(state.connection, retainedBlobHashes);
       deletedRows = totalChanges(state.connection) - beforeChanges;
       deletedBlobs = blobStats.count;
       deletedBlobBytes = blobStats.bytes;
@@ -356,21 +358,31 @@ function selectionSignature(database: Database.Database, runIds: string[]): stri
   return JSON.stringify([resourceRows, queueRows]);
 }
 
-function unreferencedBlobStats(database: Database.Database): { count: number; bytes: number } {
-  const predicate = blobReferencePredicate(database);
+function unreferencedBlobStats(
+  database: Database.Database,
+  retainedBlobHashes: readonly Buffer[],
+): { count: number; bytes: number } {
+  const predicate = blobReferencePredicate(database, retainedBlobHashes.length);
   const row = database
     .prepare(
       `SELECT count(*) AS count, COALESCE(sum(byte_length), 0) AS bytes FROM blobs WHERE ${predicate}`,
     )
-    .get();
+    .get(...retainedBlobHashes);
   return isBlobStatsRow(row) ? row : { count: 0, bytes: 0 };
 }
 
-function deleteUnreferencedBlobs(database: Database.Database): void {
-  database.prepare(`DELETE FROM blobs WHERE ${blobReferencePredicate(database)}`).run();
+function deleteUnreferencedBlobs(
+  database: Database.Database,
+  retainedBlobHashes: readonly Buffer[],
+): void {
+  database
+    .prepare(
+      `DELETE FROM blobs WHERE ${blobReferencePredicate(database, retainedBlobHashes.length)}`,
+    )
+    .run(...retainedBlobHashes);
 }
 
-function blobReferencePredicate(database: Database.Database): string {
+function blobReferencePredicate(database: Database.Database, retainedBlobCount: number): string {
   const tables = database
     .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
     .all()
@@ -387,7 +399,13 @@ function blobReferencePredicate(database: Database.Database): string {
       );
     }
   }
-  return references.length === 0 ? "1 = 1" : `blob_hash NOT IN (${references.join(" UNION ")})`;
+  const unreferenced =
+    references.length === 0 ? "1 = 1" : `blob_hash NOT IN (${references.join(" UNION ")})`;
+  if (retainedBlobCount === 0) return unreferenced;
+  const retainedPlaceholders = placeholders(
+    Array.from({ length: retainedBlobCount }, () => undefined),
+  );
+  return `${unreferenced} AND blob_hash NOT IN (${retainedPlaceholders})`;
 }
 
 function descendants(root: string, children: Map<string, string[]>): string[] {

package/src/state/schema.ts

@@ -302,8 +302,8 @@ CREATE TABLE host_commands (
     'workflowMessage.reportBranch', 'workflowTurn.report', 'sessionView.clearTerminal',
     'run.restart', 'run.changeSettings', 'followUp.queue', 'followUp.remove', 'session.record',
     'channel.reload', 'channel.recover',
-    'controller.list', 'controller.get', 'controller.apply', 'controller.reconcile', 'controller.delete',
-    'host.status', 'host.stop', 'state.backup', 'state.prune'
+    'resourceManager.list', 'resourceManager.get', 'resourceManager.apply', 'resourceManager.reconcile', 'resourceManager.delete',
+    'server.status', 'server.stop', 'state.backup', 'state.prune'
   )),
   idempotency_key TEXT NOT NULL,
   request_fingerprint BLOB NOT NULL CHECK (length(request_fingerprint) = 32),

package/src/state/workflow-messages.ts

@@ -92,7 +92,7 @@ type WorkflowTurnRow = {
   endedAt: number | null;
 };
 
-/** Durable workflow content that the host requires Pi to add to one origin session. */
+/** Durable workflow content that the server requires Pi to add to one origin session. */
 export class WorkflowMessageStore {
   constructor(readonly state: StateDatabase) {}
 

package/src/viewer/backup.ts

@@ -10,7 +10,7 @@ export function verifyInactiveBackup(
   const resolved = path.resolve(databasePath);
   const active = path.resolve(activeDatabasePath);
   if (sameFile(resolved, active)) {
-    throw new Error("Active workflow state must be verified through the workflow host");
+    throw new Error("Active workflow state must be verified through the workflow server");
   }
   const state = new StateDatabase({ filePath: resolved, mode: "read-only" });
   try {

package/src/viewer/cli.ts

@@ -12,35 +12,35 @@ import { renderClientView, runViewer } from "./tui.js";
 
 const CLI_CLIENT_ID = "pi-workflows-cli";
 
-const USAGE = `pi-workflows — workflow runs and controller resources
+const USAGE = `pi-workflows — workflow runs and managed resources
 
 Usage:
   pi-workflows view [runId] [--once]
   pi-workflows runs
-  pi-workflows controllers
-  pi-workflows controller <controller> <key>
+  pi-workflows resource-managers
+  pi-workflows resource-manager <resource-manager> <key>
   pi-workflows state status
   pi-workflows state verify [inactive-backup]
   pi-workflows state backup <destination>
   pi-workflows state prune --before <timestamp> --dry-run
   pi-workflows state prune --before <timestamp> --backup <absolute-path> --apply
-  pi-workflows host start
-  pi-workflows host status
-  pi-workflows host stop
-  pi-workflows host run [-- <extra pi args>]
+  pi-workflows server start
+  pi-workflows server status
+  pi-workflows server stop
+  pi-workflows server run [-- <extra pi args>]
   pi-workflows herdr sync [--json]
   pi-workflows herdr setup [--json]
 
-Active state is available only through the package-owned workflow host.
+Active state is available only through the package-owned workflow server.
 `;
 
 export type CliArgs = {
   command: string;
   runId?: string;
-  controllerName?: string;
+  resourceManagerName?: string;
   resourceKey?: string;
   herdrAction?: string;
-  hostAction?: "start" | "status" | "stop" | "run";
+  serverAction?: "start" | "status" | "stop" | "run";
   stateAction?: "status" | "verify" | "backup" | "prune";
   backupDestination?: string;
   verifyBackup?: string;
@@ -55,9 +55,16 @@ export function parseCliArgs(argv: string[]): CliArgs {
   const args = [...argv];
   const command = args[0] && !args[0].startsWith("-") ? (args.shift() as string) : "view";
   if (
-    !["view", "runs", "controllers", "controller", "state", "host", "herdr", "help"].includes(
-      command,
-    )
+    ![
+      "view",
+      "runs",
+      "resource-managers",
+      "resource-manager",
+      "state",
+      "server",
+      "herdr",
+      "help",
+    ].includes(command)
   ) {
     throw new Error(`Unknown command: ${command}`);
   }
@@ -87,23 +94,24 @@ export function parseCliArgs(argv: string[]): CliArgs {
   }
 
   if (command !== "herdr" && json) throw new Error("--json is available only for herdr sync");
-  if (command === "host") {
-    if (project !== undefined) throw new Error("The global host does not accept --project");
+  if (command === "server") {
+    if (project !== undefined) throw new Error("The global server does not accept --project");
     const action = positionals[0];
     if (action !== "start" && action !== "status" && action !== "stop" && action !== "run") {
-      throw new Error("host requires start, status, stop, or run");
+      throw new Error("server requires start, status, stop, or run");
     }
-    if (positionals.length !== 1) throw new Error("host accepts one lifecycle action");
+    if (positionals.length !== 1) throw new Error("server accepts one lifecycle action");
     if (piArgs.length > 0 && action !== "run") {
-      throw new Error("Extra Pi arguments are available only for host run");
+      throw new Error("Extra Pi arguments are available only for server run");
     }
-    return { command, hostAction: action, once, json, piArgs };
+    return { command, serverAction: action, once, json, piArgs };
   }
-  if (command === "controller") {
-    if (positionals.length !== 2) throw new Error("controller requires <controller> and <key>");
+  if (command === "resource-manager") {
+    if (positionals.length !== 2)
+      throw new Error("resource-manager requires <resource-manager> and <key>");
     return {
       command,
-      controllerName: positionals[0] as string,
+      resourceManagerName: positionals[0] as string,
       resourceKey: positionals[1] as string,
       once,
       json,
@@ -188,8 +196,8 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
   }
 
   try {
-    if (args.command === "host") {
-      return await runHost(args.hostAction as "start" | "status" | "stop" | "run", args.piArgs);
+    if (args.command === "server") {
+      return await runServer(args.serverAction as "start" | "status" | "stop" | "run", args.piArgs);
     }
     if (args.command === "herdr") {
       const result = syncHerdrPlugin(packageRoot());
@@ -223,13 +231,17 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
         printJsonLines(runs);
         return 0;
       }
-      if (args.command === "controllers" || args.command === "controller") {
+      if (args.command === "resource-managers" || args.command === "resource-manager") {
         const response = await client.request({
-          operation: args.command === "controllers" ? "controller.list" : "controller.get",
+          operation:
+            args.command === "resource-managers" ? "resourceManager.list" : "resourceManager.get",
           payload: {
             projectPath: process.cwd(),
-            ...(args.command === "controller"
-              ? { controller: args.controllerName as string, key: args.resourceKey as string }
+            ...(args.command === "resource-manager"
+              ? {
+                  resourceManager: args.resourceManagerName as string,
+                  key: args.resourceKey as string,
+                }
               : {}),
           },
         });
@@ -298,19 +310,19 @@ async function runStateCommand(client: WorkflowClient, args: CliArgs): Promise<v
   process.stdout.write(`${JSON.stringify(response.receipt ?? {})}\n`);
 }
 
-async function runHost(
+async function runServer(
   action: "start" | "status" | "stop" | "run",
   piArgs: string[] | undefined,
 ): Promise<number> {
   if (action === "run") {
-    const { WorkflowHost } = await import("../host/runner.js");
-    const host = new WorkflowHost({
+    const { WorkflowServer } = await import("../server/server.js");
+    const server = new WorkflowServer({
       piArgs: piArgs ?? [],
-      onLog: (message) => process.stdout.write(`[host] ${message}\n`),
+      onLog: (message) => process.stdout.write(`[server] ${message}\n`),
     });
-    await host.start();
+    await server.start();
     await new Promise<void>((resolve) => {
-      const shutdown = () => void host.stop().then(resolve);
+      const shutdown = () => void server.stop().then(resolve);
       process.once("SIGTERM", shutdown);
       process.once("SIGINT", shutdown);
     });
@@ -321,7 +333,9 @@ async function runHost(
     const response =
       action === "start"
         ? await client.ensureRunning()
-        : await client.request({ operation: action === "status" ? "host.status" : "host.stop" });
+        : await client.request({
+            operation: action === "status" ? "server.status" : "server.stop",
+          });
     process.stdout.write(`${JSON.stringify(response.receipt ?? {})}\n`);
     return response.outcome === "accepted" || response.outcome === "adopted" ? 0 : 1;
   } finally {
@@ -364,7 +378,7 @@ function printJsonLines(value: JsonValue): void {
 
 function requireAccepted(response: { outcome: string; error?: string }): void {
   if (response.outcome !== "accepted" && response.outcome !== "adopted") {
-    throw new Error(response.error ?? `Workflow host returned ${response.outcome}`);
+    throw new Error(response.error ?? `Workflow server returned ${response.outcome}`);
   }
 }
 

package/src/viewer/tui.ts

@@ -13,7 +13,7 @@ export type ViewerOptions = {
   runId?: string | undefined;
 };
 
-/** Interactive client view. All durable reads stay in the workflow host. */
+/** Interactive client view. All durable reads stay in the workflow server. */
 export async function runViewer(options: ViewerOptions): Promise<void> {
   let value: JsonValue = options.runId === undefined ? [] : null;
   let selected = 0;

package/src/workflows/command-batch.ts

@@ -117,8 +117,8 @@ export async function runCommandBatch(
     }
   };
 
-  const workerCount = Math.min(request.maxConcurrency, total);
-  await Promise.all(Array.from({ length: workerCount }, worker));
+  const runnerCount = Math.min(request.maxConcurrency, total);
+  await Promise.all(Array.from({ length: runnerCount }, worker));
 
   for (let index = 0; index < total; index += 1) {
     if (results[index] !== undefined) continue;

package/src/workflows/engine.ts

@@ -332,12 +332,11 @@ export class WorkflowEngine {
     validateWorkflowDefinition(workflow);
     this.presentationRequired = workflow.presentationPrompt !== undefined;
     // Reset before any await: a park or cancel landing during preparation
-    // must survive, or a host drain would hang while the run executes.
+    // must survive, or a server drain would hang while the run executes.
     this.cancelled = false;
     this.paused = false;
     this.parked = false;
-    const loaded = await this.store.prepareRunResume(runId);
-    const state = loaded.state;
+    const state = await this.store.prepareRunResume(runId);
     const sourceMismatch = workflowIdentityMismatch(state, workflow, options.workflowSource);
     if (sourceMismatch && options.force !== true) {
       throw new WorkflowSourceChangedError(runId);
@@ -456,21 +455,21 @@ export class WorkflowEngine {
     this.cancelled = false;
     this.paused = false;
     this.parked = false;
-    const parent = await this.store.readRun(parentRunId);
-    if (parent === null) {
+    const parentState = await this.store.readRunState(parentRunId);
+    if (parentState === null) {
       throw new Error(`Cannot continue from unreadable workflow run: ${parentRunId}`);
     }
-    if (parent.state.status !== "waiting" || parent.state.waitingOn === undefined) {
+    if (parentState.status !== "waiting" || parentState.waitingOn === undefined) {
       throw new Error(
-        `Cannot continue workflow run ${parentRunId} with status ${parent.state.status}`,
+        `Cannot continue workflow run ${parentRunId} with status ${parentState.status}`,
       );
     }
-    const sourceMismatch = workflowIdentityMismatch(parent.state, workflow, options.workflowSource);
+    const sourceMismatch = workflowIdentityMismatch(parentState, workflow, options.workflowSource);
     if (sourceMismatch && options.force !== true) {
       throw new WorkflowSourceChangedError(parentRunId);
     }
 
-    const waitingNodeId = parent.state.waitingOn;
+    const waitingNodeId = parentState.waitingOn;
     const waitingNode = workflow.nodes[waitingNodeId];
     const humanContract =
       waitingNode?.nodeType === "checkpoint" ? waitingNode.humanDecision : undefined;
@@ -481,7 +480,7 @@ export class WorkflowEngine {
       if (options.humanDecision === undefined) {
         throw new Error(`Checkpoint ${waitingNodeId} requires an accepted verified human decision`);
       }
-      const request = parent.state.finalOutput as HumanDecisionRequest;
+      const request = parentState.finalOutput as HumanDecisionRequest;
       if (
         request?.schema !== "pi-workflows.human-decision-request.v1" ||
         request.decisionId !== options.humanDecision.decisionId ||
@@ -495,7 +494,7 @@ export class WorkflowEngine {
       }
       acceptedResponse = validateHumanDecisionResponse(request, durableDecision.response);
       acceptedNodeId = request.nodeId;
-      normalizedInput = structuredClone(parent.state.input);
+      normalizedInput = structuredClone(parentState.input);
     } else {
       const suppliedInput = input === undefined ? null : input;
       normalizedInput = workflow.input ? await workflow.input(suppliedInput) : suppliedInput;
@@ -512,9 +511,9 @@ export class WorkflowEngine {
       options.runId,
     );
     state.parentRunId = parentRunId;
-    state.outputs = structuredClone(parent.state.outputs);
-    state.results = structuredClone(parent.state.results);
-    state.steps = structuredClone(parent.state.steps);
+    state.outputs = structuredClone(parentState.outputs);
+    state.results = structuredClone(parentState.results);
+    state.steps = structuredClone(parentState.steps);
     if (humanContract !== undefined && options.humanDecision !== undefined) {
       const receipt = {
         decisionId: options.humanDecision.decisionId,
@@ -557,7 +556,7 @@ export class WorkflowEngine {
         ...(state.runTitle ? { runTitle: state.runTitle } : {}),
         input: state.input,
         continuedFrom: parentRunId,
-        checkpoint: parent.state.waitingOn,
+        checkpoint: parentState.waitingOn,
         carriedSteps: state.steps.length,
       },
     });

package/src/workflows/store.ts

@@ -156,7 +156,7 @@ export type WorkflowRunTerminalData = {
 
 export type WorkflowRunStoreOptions = {
   authorityProvider?: (runId: string) => RunWriteAuthority | undefined;
-  /** Host-owned projection updates that must commit with each run snapshot. */
+  /** Server-owned projection updates that must commit with each run snapshot. */
   snapshotLifecycle?: (context: {
     runId: string;
     state: WorkflowRunState;
@@ -164,13 +164,13 @@ export type WorkflowRunStoreOptions = {
     database: StateDatabase;
     now: number;
   }) => void;
-  /** The global host may record an attested Pi session after the worker lease ends. */
-  allowHostSessionRecording?: boolean;
+  /** The global server may record an attested Pi session after the runner lease ends. */
+  allowServerSessionRecording?: boolean;
   state?: StateDatabase;
   readOnly?: boolean;
 };
 
-/** The state boundary used by workflow code, including out-of-process workers. */
+/** The state boundary used by workflow code, including out-of-process runners. */
 export interface WorkflowExecutionStore {
   readonly databasePath: string;
   initializeRun(
@@ -178,11 +178,8 @@ export interface WorkflowExecutionStore {
     state: WorkflowRunState,
     options?: InitializeWorkflowRunOptions,
   ): Promise<string>;
-  prepareRunResume(runId: string): Promise<LoadedWorkflowRun>;
-  readRun(
-    runId: string,
-    options?: ReadWorkflowRunOptions,
-  ): LoadedWorkflowRun | null | Promise<LoadedWorkflowRun | null>;
+  prepareRunResume(runId: string): Promise<WorkflowRunState>;
+  readRunState(runId: string): WorkflowRunState | null | Promise<WorkflowRunState | null>;
   writeSnapshot(
     runId: string,
     state: WorkflowRunState,
@@ -499,7 +496,7 @@ export class WorkflowRunStore {
     | ((runId: string) => RunWriteAuthority | undefined)
     | undefined;
   private readonly snapshotLifecycle: WorkflowRunStoreOptions["snapshotLifecycle"];
-  private readonly allowHostSessionRecording: boolean;
+  private readonly allowServerSessionRecording: boolean;
   private readonly contexts = new Map<string, RunContext>();
   private readonly ownsState: boolean;
   private readonly mutations: StateMutationStore;
@@ -508,7 +505,7 @@ export class WorkflowRunStore {
   constructor(databasePath: string = workflowStatePath(), options: WorkflowRunStoreOptions = {}) {
     this.authorityProvider = options.authorityProvider;
     this.snapshotLifecycle = options.snapshotLifecycle;
-    this.allowHostSessionRecording = options.allowHostSessionRecording === true;
+    this.allowServerSessionRecording = options.allowServerSessionRecording === true;
     this.ownsState = options.state === undefined;
     this.state =
       options.state ??
@@ -526,7 +523,7 @@ export class WorkflowRunStore {
     if (this.ownsState) this.state.close();
   }
 
-  /** Host-only synchronization after a queue lifecycle mutation on the run resource. */
+  /** Server-only synchronization after a queue lifecycle mutation on the run resource. */
   synchronizeRevision(runId: string): number {
     const revision = this.resourceRevision(runId);
     const context = this.contexts.get(runId);
@@ -1466,11 +1463,11 @@ export class WorkflowRunStore {
     return { runId, originSessionId, followUps };
   }
 
-  async prepareRunResume(runId: string): Promise<LoadedWorkflowRun> {
-    const loaded = this.readRun(runId, { includeTrace: true });
-    if (loaded === null) throw new Error(`Cannot resume unreadable workflow run: ${runId}`);
-    if (loaded.state.status !== "running") {
-      throw new Error(`Cannot resume workflow run ${runId} with status ${loaded.state.status}`);
+  async prepareRunResume(runId: string): Promise<WorkflowRunState> {
+    const state = this.readRunState(runId);
+    if (state === null) throw new Error(`Cannot resume unreadable workflow run: ${runId}`);
+    if (state.status !== "running") {
+      throw new Error(`Cannot resume workflow run ${runId} with status ${state.status}`);
     }
     this.verifySettingsProjections(runId);
     const revision = this.resourceRevision(runId);
@@ -1498,20 +1495,20 @@ export class WorkflowRunStore {
         payload: {},
       };
       insertRunEvent(this.state, row.resourceId, nextRevision, at, traceEvent);
-      loaded.state.traceSeq = nextRevision;
-      loaded.state.updatedAt = at;
-      this.persistRunState(row, loaded.state, nextRevision, now);
-      recordViewerDeltas(this.state, runId, runViewerTargets(loaded.state, traceEvent), now);
+      state.traceSeq = nextRevision;
+      state.updatedAt = at;
+      this.persistRunState(row, state, nextRevision, now);
+      recordViewerDeltas(this.state, runId, runViewerTargets(state, traceEvent), now);
       context.revision = nextRevision;
     });
-    const prepared = this.readRun(runId, { includeTrace: true });
+    const prepared = this.readRunState(runId);
     if (prepared === null) throw new Error(`Workflow run became unreadable: ${runId}`);
     return prepared;
   }
 
   async markRunInterrupted(
     runId: string,
-    reason = "Workflow host stopped before the run finished",
+    reason = "Workflow server stopped before the run finished",
   ): Promise<LoadedWorkflowRun | null> {
     const loaded = this.readRun(runId);
     if (loaded === null || loaded.state.status !== "running") return loaded;
@@ -1549,7 +1546,7 @@ export class WorkflowRunStore {
     );
   }
 
-  /** Host-only synchronous form for an already serialized command transaction. */
+  /** Server-only synchronous form for an already serialized command transaction. */
   publishUpdateSynchronous(
     runId: string,
     state: WorkflowRunState,
@@ -1765,7 +1762,7 @@ export class WorkflowRunStore {
           },
         };
         insertRunEvent(this.state, run.resourceId, revision, at, traceEvent);
-        const current = this.readRunState(run, this.readDefinition(run.definitionHash));
+        const current = this.materializeRunState(run, this.readDefinition(run.definitionHash));
         current.traceSeq = revision;
         current.updatedAt = at;
         this.persistRunState(run, current, revision, now);
@@ -2246,11 +2243,17 @@ export class WorkflowRunStore {
     };
   }
 
+  readRunState(runId: string): WorkflowRunState | null {
+    const row = this.readRunRow(runId);
+    if (row === undefined) return null;
+    return this.materializeRunState(row, this.readDefinition(row.definitionHash));
+  }
+
   readRun(runId: string, options: ReadWorkflowRunOptions = {}): LoadedWorkflowRun | null {
     const row = this.readRunRow(runId);
     if (row === undefined) return null;
     const snapshot = this.readDefinition(row.definitionHash);
-    const state = this.readRunState(row, snapshot);
+    const state = this.materializeRunState(row, snapshot);
     const segments = this.segmentRows(runId).map((segment) => this.loadSegment(segment, state));
     const flat = segments.find((segment) => segment.attemptId === "") ?? emptySegment();
     return {
@@ -2529,7 +2532,7 @@ export class WorkflowRunStore {
 
   private assertSessionWriteAuthority(runId: string): void {
     const run = this.requireRunRow(runId);
-    if (this.allowHostSessionRecording) return;
+    if (this.allowServerSessionRecording) return;
     this.assertWriteAuthority(run, this.contextFor(runId).revision);
   }
 
@@ -3522,7 +3525,7 @@ export class WorkflowRunStore {
     return row;
   }
 
-  private readRunState(row: RunRow, snapshot: WorkflowDefinitionSnapshot): WorkflowRunState {
+  private materializeRunState(row: RunRow, snapshot: WorkflowDefinitionSnapshot): WorkflowRunState {
     const steps = this.readSteps(row.runId);
     return this.buildRunState(
       row,

package/src/workflows/types.ts

@@ -96,7 +96,7 @@ export type WorkflowProgressData = {
 export type WorkflowNodeCommon = {
   /**
    * Per-node active-execution timeout or a callback that derives it from the run context.
-   * Waiting, paused, disconnected, and host-down origin-session time does not count.
+   * Waiting, paused, disconnected, and server-down origin-session time does not count.
    * Null disables the deadline. Omission falls back to the engine default (15 minutes).
    */
   timeoutMs?: number | null | ((context: WorkflowNodeContext) => MaybePromise<number | null>);
@@ -962,7 +962,7 @@ export type WorkflowEngineOptions = {
   notificationSink?: WorkflowNotificationSink;
   /** Canonical SQLite database. Defaults to `~/.pi/agent/workflows/state.sqlite`. */
   databasePath?: string;
-  /** Durable execution store. Workers use a host-backed implementation. */
+  /** Durable execution store. Runners use a server-backed implementation. */
   store?: import("./store.js").WorkflowExecutionStore;
   /**
    * Awaited after `run_started` is persisted, before any node executes.

package/dist/controllers/conditions.d.ts

@@ -1,6 +0,0 @@
-import type { ControllerCondition, ControllerConditionInput, ControllerResourceStatus, ControllerStatusPatch } from "./types.js";
-export declare function conditionTrue(type: string, reason: string, message?: string): ControllerConditionInput;
-export declare function conditionFalse(type: string, reason: string, message?: string): ControllerConditionInput;
-export declare function conditionUnknown(type: string, reason: string, message?: string): ControllerConditionInput;
-export declare function applyStatusPatch<TStatus>(current: ControllerResourceStatus<TStatus>, patch: ControllerStatusPatch<TStatus> | undefined, generation: number, now: string): ControllerResourceStatus<TStatus>;
-export declare function mergeConditions(current: ControllerCondition[], updates: ControllerConditionInput[], generation: number, now: string): ControllerCondition[];