@osolmaz/pi-workflows 0.16.1 → 0.16.3

package/src/{controllers → resource-managers}/sqlite.ts

@@ -5,14 +5,15 @@ import { StateDatabase, workflowStatePath } from "../state/database.js";
 import { canonicalJson } from "../state/json.js";
 import { resourceIdFor, tokenHash } from "../state/mutation.js";
 import { initializeViewerRun, recordViewerDeltas } from "../state/viewer.js";
+import { WorkflowMessageStore } from "../state/workflow-messages.js";
 import {
   EffectRequestConflictError,
-  ResourceConflictError,
-  ResourceNotFoundError,
+  ManagedResourceConflictError,
+  ManagedResourceNotFoundError,
   WorkflowRequestConflictError,
 } from "./errors.js";
 import type {
-  ControllerStore,
+  ResourceManagerStore,
   EffectReservation,
   QueueItem,
   QueueRequeueOptions,
@@ -21,11 +22,11 @@ import type {
 } from "./store.js";
 import type {
   ChildWorkflowRecord,
-  ControllerEvent,
-  ControllerQueueClaim,
-  ControllerResource,
-  ControllerResourceRef,
-  ControllerResourceStatus,
+  ResourceManagerEvent,
+  ResourceManagerQueueClaim,
+  ManagedResource,
+  ManagedResourceRef,
+  ManagedResourceStatus,
   EffectRecord,
   JsonObject,
 } from "./types.js";
@@ -138,11 +139,11 @@ export type RunEventRecord = {
   payload: JsonObject;
 };
 
-type ControllerRow = {
-  controllerResourceId: string;
+type ResourceManagerRow = {
+  managedResourceId: string;
   resourceId: string;
   resourceVersion: number;
-  controllerName: string;
+  resourceManagerName: string;
   resourceKey: string;
   uid: string;
   generation: number;
@@ -267,9 +268,10 @@ type WorkflowRow = {
   errorHash: Buffer | null;
 };
 
-export class SqliteControllerStore implements ControllerStore {
+export class SqliteResourceManagerStore implements ResourceManagerStore {
   readonly filePath: string;
   readonly state: StateDatabase;
+  private readonly workflowMessages: WorkflowMessageStore;
   private readonly ownsState: boolean;
   private readonly projectId: string | null;
   private closed = false;
@@ -280,7 +282,7 @@ export class SqliteControllerStore implements ControllerStore {
       readOnly?: boolean;
       projectPath?: string;
       state?: StateDatabase;
-      /** Host-only global view. Project-scoped mutations still require projectPath. */
+      /** Server-only global view. Project-scoped mutations still require projectPath. */
       global?: boolean;
     } = {},
   ) {
@@ -293,6 +295,7 @@ export class SqliteControllerStore implements ControllerStore {
         checkLegacyState: filePath === workflowStatePath(),
       });
     this.filePath = this.state.filePath;
+    this.workflowMessages = new WorkflowMessageStore(this.state);
     if (options.global === true) {
       this.projectId = null;
     } else {
@@ -309,31 +312,34 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   putResource<TSpec, TStatus>(options: {
-    controller: string;
+    resourceManager: string;
     key: string;
     spec: TSpec;
     initialStatus: TStatus;
     now?: string;
-  }): ControllerResource<TSpec, TStatus> {
+  }): ManagedResource<TSpec, TStatus> {
     this.assertWritable();
-    validateName(options.controller, "controller");
+    validateName(options.resourceManager, "resource manager");
     validateKey(options.key, "resource key");
     const now = epoch(validTimestamp(options.now));
     const specHash = this.state.putJson(options.spec, now);
-    const initialStatus: ControllerResourceStatus<TStatus> = {
+    const initialStatus: ManagedResourceStatus<TStatus> = {
       observedGeneration: 0,
       conditions: [],
-      controllerStatus: options.initialStatus,
+      resourceManagerStatus: options.initialStatus,
     };
     const statusHash = this.state.putJson(initialStatus, now);
     return this.state.transaction(() => {
-      const existing = this.controllerRow({ controller: options.controller, key: options.key });
+      const existing = this.resourceManagerRow({
+        resourceManager: options.resourceManager,
+        key: options.key,
+      });
       if (existing === undefined) {
         const uid = randomUUID();
-        const controllerResourceId = `controller-resource-${randomUUID()}`;
+        const managedResourceId = `controller-resource-${randomUUID()}`;
         const resourceId = resourceIdFor(
           "controller",
-          `${this.requireProjectId()}:${options.controller}:${options.key}`,
+          `${this.requireProjectId()}:${options.resourceManager}:${options.key}`,
         );
         this.state.connection
           .prepare(
@@ -341,7 +347,7 @@ export class SqliteControllerStore implements ControllerStore {
                resource_id, resource_type, aggregate_key, revision, created_at, updated_at
              ) VALUES (?, 'controller', ?, 1, ?, ?)`,
           )
-          .run(resourceId, controllerResourceId, now, now);
+          .run(resourceId, managedResourceId, now, now);
         this.state.connection
           .prepare("INSERT INTO leases(resource_id, generation) VALUES (?, 0)")
           .run(resourceId);
@@ -353,10 +359,10 @@ export class SqliteControllerStore implements ControllerStore {
              ) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?)`,
           )
           .run(
-            controllerResourceId,
+            managedResourceId,
             resourceId,
             this.requireProjectId(),
-            options.controller,
+            options.resourceManager,
             options.key,
             uid,
             specHash,
@@ -364,7 +370,7 @@ export class SqliteControllerStore implements ControllerStore {
             now,
             now,
           );
-        this.enqueueControllerRow(controllerResourceId, now, now);
+        this.enqueueResourceManagerRow(managedResourceId, now, now);
         this.insertEvent(
           resourceId,
           1,
@@ -382,9 +388,9 @@ export class SqliteControllerStore implements ControllerStore {
              SET spec_hash = ?, generation = generation + 1, updated_at = ?
              WHERE controller_resource_id = ?`,
           )
-          .run(specHash, now, existing.controllerResourceId);
+          .run(specHash, now, existing.managedResourceId);
         this.bumpResource(existing.resourceId, existing.resourceVersion, now);
-        this.enqueueControllerRow(existing.controllerResourceId, now, now);
+        this.enqueueResourceManagerRow(existing.managedResourceId, now, now);
         this.insertEvent(
           existing.resourceId,
           revision,
@@ -396,74 +402,74 @@ export class SqliteControllerStore implements ControllerStore {
         );
       }
       return this.requireResource({
-        controller: options.controller,
+        resourceManager: options.resourceManager,
         key: options.key,
-      }) as ControllerResource<TSpec, TStatus>;
+      }) as ManagedResource<TSpec, TStatus>;
     });
   }
 
   getResource<TSpec = unknown, TStatus = unknown>(
-    ref: ControllerResourceRef,
-  ): ControllerResource<TSpec, TStatus> | undefined {
-    const row = this.controllerRow(ref);
+    ref: ManagedResourceRef,
+  ): ManagedResource<TSpec, TStatus> | undefined {
+    const row = this.resourceManagerRow(ref);
     return row === undefined
       ? undefined
-      : (this.mapControllerResource(row) as ControllerResource<TSpec, TStatus>);
+      : (this.mapManagedResource(row) as ManagedResource<TSpec, TStatus>);
   }
 
-  getResourceByUid(uid: string): ControllerResource | undefined {
-    const row = this.state.connection.prepare(controllerSelect("WHERE c.uid = ?")).get(uid);
-    return isControllerRow(row) ? this.mapControllerResource(row) : undefined;
+  getResourceByUid(uid: string): ManagedResource | undefined {
+    const row = this.state.connection.prepare(resourceManagerSelect("WHERE c.uid = ?")).get(uid);
+    return isResourceManagerRow(row) ? this.mapManagedResource(row) : undefined;
   }
 
   listResources<TSpec = unknown, TStatus = unknown>(
-    options: { controller?: string } = {},
-  ): ControllerResource<TSpec, TStatus>[] {
+    options: { resourceManager?: string } = {},
+  ): ManagedResource<TSpec, TStatus>[] {
     const clauses = ["1 = 1"];
     const params: unknown[] = [];
     if (this.projectId !== null) {
       clauses.push("c.project_id = ?");
       params.push(this.projectId);
     }
-    if (options.controller !== undefined) {
+    if (options.resourceManager !== undefined) {
       clauses.push("c.controller_name = ?");
-      params.push(options.controller);
+      params.push(options.resourceManager);
     }
     const rows = this.state.connection
       .prepare(
-        controllerSelect(
+        resourceManagerSelect(
           `WHERE ${clauses.join(" AND ")} ORDER BY c.controller_name, c.resource_key`,
         ),
       )
       .all(...params);
     return rows
-      .filter(isControllerRow)
-      .map((row) => this.mapControllerResource(row) as ControllerResource<TSpec, TStatus>);
+      .filter(isResourceManagerRow)
+      .map((row) => this.mapManagedResource(row) as ManagedResource<TSpec, TStatus>);
   }
 
   updateStatus<TStatus>(options: {
-    ref: ControllerResourceRef;
+    ref: ManagedResourceRef;
     expectedResourceVersion: number;
-    claim: ControllerQueueClaim;
-    status: ControllerResourceStatus<TStatus>;
+    claim: ResourceManagerQueueClaim;
+    status: ManagedResourceStatus<TStatus>;
     finalizers?: string[];
     now?: string;
-  }): ControllerResource<unknown, TStatus> {
+  }): ManagedResource<unknown, TStatus> {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
-      const row = this.requireControllerRow(options.ref);
-      this.assertControllerClaim(row, options.claim, now);
+      const row = this.requireResourceManagerRow(options.ref);
+      this.assertResourceManagerClaim(row, options.claim, now);
       if (row.resourceVersion !== options.expectedResourceVersion) {
-        throw new ResourceConflictError(options.ref.controller, options.ref.key);
+        throw new ManagedResourceConflictError(options.ref.resourceManager, options.ref.key);
       }
       const statusHash = this.state.putJson(options.status, now);
       this.state.connection
         .prepare(
           "UPDATE controller_resources SET status_hash = ?, updated_at = ? WHERE controller_resource_id = ?",
         )
-        .run(statusHash, now, row.controllerResourceId);
+        .run(statusHash, now, row.managedResourceId);
       if (options.finalizers !== undefined)
-        this.replaceFinalizers(row.controllerResourceId, options.finalizers);
+        this.replaceFinalizers(row.managedResourceId, options.finalizers);
       this.bumpResource(row.resourceId, row.resourceVersion, now);
       this.insertEvent(
         row.resourceId,
@@ -476,22 +482,22 @@ export class SqliteControllerStore implements ControllerStore {
         options.claim.generation,
       );
       options.claim.resourceVersion = row.resourceVersion + 1;
-      return this.requireResource(options.ref) as ControllerResource<unknown, TStatus>;
+      return this.requireResource(options.ref) as ManagedResource<unknown, TStatus>;
     });
   }
 
-  requestDeletion(ref: ControllerResourceRef, nowValue?: string): ControllerResource {
+  requestDeletion(ref: ManagedResourceRef, nowValue?: string): ManagedResource {
     const now = epoch(validTimestamp(nowValue));
     return this.state.transaction(() => {
-      const row = this.requireControllerRow(ref);
+      const row = this.requireResourceManagerRow(ref);
       if (row.deletionRequestedAt === null) {
         this.state.connection
           .prepare(
             "UPDATE controller_resources SET deletion_requested_at = ?, updated_at = ? WHERE controller_resource_id = ?",
           )
-          .run(now, now, row.controllerResourceId);
+          .run(now, now, row.managedResourceId);
         this.bumpResource(row.resourceId, row.resourceVersion, now);
-        this.enqueueControllerRow(row.controllerResourceId, now, now);
+        this.enqueueResourceManagerRow(row.managedResourceId, now, now);
         this.insertEvent(
           row.resourceId,
           row.resourceVersion + 1,
@@ -507,21 +513,21 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   updateFinalizers(options: {
-    ref: ControllerResourceRef;
+    ref: ManagedResourceRef;
     expectedResourceVersion: number;
     finalizers: string[];
     now?: string;
-  }): ControllerResource {
+  }): ManagedResource {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
-      const row = this.requireControllerRow(options.ref);
+      const row = this.requireResourceManagerRow(options.ref);
       if (row.resourceVersion !== options.expectedResourceVersion) {
-        throw new ResourceConflictError(options.ref.controller, options.ref.key);
+        throw new ManagedResourceConflictError(options.ref.resourceManager, options.ref.key);
       }
-      this.replaceFinalizers(row.controllerResourceId, options.finalizers);
+      this.replaceFinalizers(row.managedResourceId, options.finalizers);
       this.state.connection
         .prepare("UPDATE controller_resources SET updated_at = ? WHERE controller_resource_id = ?")
-        .run(now, row.controllerResourceId);
+        .run(now, row.managedResourceId);
       this.bumpResource(row.resourceId, row.resourceVersion, now);
       this.insertEvent(
         row.resourceId,
@@ -537,50 +543,50 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   deleteResource(
-    ref: ControllerResourceRef,
+    ref: ManagedResourceRef,
     expectedResourceVersion: number,
-    claim: ControllerQueueClaim,
+    claim: ResourceManagerQueueClaim,
   ): boolean {
     return this.state.transaction(() => {
-      const row = this.requireControllerRow(ref);
-      this.assertControllerClaim(row, claim, Date.now());
+      const row = this.requireResourceManagerRow(ref);
+      this.assertResourceManagerClaim(row, claim, Date.now());
       if (row.resourceVersion !== expectedResourceVersion) {
-        throw new ResourceConflictError(ref.controller, ref.key);
+        throw new ManagedResourceConflictError(ref.resourceManager, ref.key);
       }
-      if (row.deletionRequestedAt === null || this.finalizers(row.controllerResourceId).length > 0)
+      if (row.deletionRequestedAt === null || this.finalizers(row.managedResourceId).length > 0)
         return false;
       this.state.connection
         .prepare("DELETE FROM controller_resources WHERE controller_resource_id = ?")
-        .run(row.controllerResourceId);
+        .run(row.managedResourceId);
       return true;
     });
   }
 
-  enqueue(ref: ControllerResourceRef, availableAt?: string): void {
-    const row = this.requireControllerRow(ref);
+  enqueue(ref: ManagedResourceRef, availableAt?: string): void {
+    const row = this.requireResourceManagerRow(ref);
     const now = Date.now();
-    this.enqueueControllerRow(row.controllerResourceId, epoch(validTimestamp(availableAt)), now);
+    this.enqueueResourceManagerRow(row.managedResourceId, epoch(validTimestamp(availableAt)), now);
   }
 
   claimNext(options: {
-    controllers: string[];
+    resourceManagers: string[];
     ownerId: string;
     leaseMs: number;
     now?: string;
-    exclude?: ControllerResourceRef[];
-  }): ControllerQueueClaim | undefined {
-    if (options.controllers.length === 0) return undefined;
+    exclude?: ManagedResourceRef[];
+  }): ResourceManagerQueueClaim | undefined {
+    if (options.resourceManagers.length === 0) return undefined;
     const now = epoch(validTimestamp(options.now));
-    const placeholders = options.controllers.map(() => "?").join(", ");
+    const placeholders = options.resourceManagers.map(() => "?").join(", ");
     const exclusions = options.exclude ?? [];
     const exclusionSql = exclusions
       .map(() => "AND NOT (c.controller_name = ? AND c.resource_key = ?)")
       .join("\n               ");
-    const exclusionParams = exclusions.flatMap((ref) => [ref.controller, ref.key]);
+    const exclusionParams = exclusions.flatMap((ref) => [ref.resourceManager, ref.key]);
     return this.state.transaction(() => {
       const row = this.state.connection
         .prepare(
-          `${controllerSelect(`
+          `${resourceManagerSelect(`
              JOIN controller_queue q ON q.controller_resource_id = c.controller_resource_id
              JOIN leases l ON l.resource_id = c.resource_id
              WHERE c.project_id = ?
@@ -591,8 +597,8 @@ export class SqliteControllerStore implements ControllerStore {
              ORDER BY q.available_at, c.controller_name, c.resource_key
              LIMIT 1`)}`,
         )
-        .get(this.requireProjectId(), ...options.controllers, ...exclusionParams, now, now);
-      if (!isControllerRow(row)) return undefined;
+        .get(this.requireProjectId(), ...options.resourceManagers, ...exclusionParams, now, now);
+      if (!isResourceManagerRow(row)) return undefined;
       const lease = this.requireLease(row.resourceId);
       const token = randomBytes(32).toString("base64url");
       const generation = lease.generation + 1;
@@ -630,23 +636,23 @@ export class SqliteControllerStore implements ControllerStore {
         generation,
       );
       return {
-        controller: row.controllerName,
+        resourceManager: row.resourceManagerName,
         key: row.resourceKey,
         ownerId: options.ownerId,
         token,
         generation,
-        queueVersion: this.queueVersion(row.controllerResourceId),
+        queueVersion: this.queueVersion(row.managedResourceId),
         resourceVersion: row.resourceVersion + 1,
-        consecutiveErrors: this.queueErrors(row.controllerResourceId),
+        consecutiveErrors: this.queueErrors(row.managedResourceId),
         expiresAt: new Date(expiresAt).toISOString(),
       };
     });
   }
 
-  renewClaim(claim: ControllerQueueClaim, leaseMs: number, nowValue?: string): boolean {
+  renewClaim(claim: ResourceManagerQueueClaim, leaseMs: number, nowValue?: string): boolean {
     const now = epoch(validTimestamp(nowValue));
     const expiresAt = now + leaseMs;
-    const row = this.controllerRow({ controller: claim.controller, key: claim.key });
+    const row = this.resourceManagerRow({ resourceManager: claim.resourceManager, key: claim.key });
     if (row === undefined) return false;
     const result = this.state.connection
       .prepare(
@@ -667,22 +673,22 @@ export class SqliteControllerStore implements ControllerStore {
     return result.changes === 1;
   }
 
-  settleClaim(claim: ControllerQueueClaim, nowValue?: string): boolean {
-    return this.settleControllerClaim(claim, undefined, nowValue);
+  settleClaim(claim: ResourceManagerQueueClaim, nowValue?: string): boolean {
+    return this.settleResourceManagerClaim(claim, undefined, nowValue);
   }
 
   requeueClaim(
-    claim: ControllerQueueClaim,
+    claim: ResourceManagerQueueClaim,
     options: QueueRequeueOptions,
     nowValue?: string,
   ): boolean {
-    return this.settleControllerClaim(claim, options, nowValue);
+    return this.settleResourceManagerClaim(claim, options, nowValue);
   }
 
   listQueue(): QueueItem[] {
     const rows = this.state.connection
       .prepare(
-        `SELECT c.controller_name AS controller, c.resource_key AS resourceKey,
+        `SELECT c.controller_name AS resourceManager, c.resource_key AS resourceKey,
                 q.available_at AS availableAt, q.consecutive_errors AS consecutiveErrors,
                 l.expires_at AS claimExpiresAt
          FROM controller_queue q
@@ -692,7 +698,7 @@ export class SqliteControllerStore implements ControllerStore {
       )
       .all(this.requireProjectId());
     return rows.filter(isQueueListRow).map((row) => ({
-      controller: row.controller,
+      resourceManager: row.resourceManager,
       key: row.resourceKey,
       availableAt: new Date(row.availableAt).toISOString(),
       consecutiveErrors: row.consecutiveErrors,
@@ -705,7 +711,7 @@ export class SqliteControllerStore implements ControllerStore {
   reserveEffect(options: {
     key: string;
     resourceUid: string;
-    claim: ControllerQueueClaim;
+    claim: ResourceManagerQueueClaim;
     generation: number;
     kind: string;
     requestFingerprint: string;
@@ -713,8 +719,8 @@ export class SqliteControllerStore implements ControllerStore {
   }): EffectReservation {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
-      const source = this.requireControllerRowByUid(options.resourceUid);
-      this.assertControllerClaim(source, options.claim, now);
+      const source = this.requireResourceManagerRowByUid(options.resourceUid);
+      this.assertResourceManagerClaim(source, options.claim, now);
       const effectId = effectIdFor(source.resourceId, options.key);
       const existing = this.effectRow(options.resourceUid, options.key);
       if (existing !== undefined) {
@@ -791,7 +797,7 @@ export class SqliteControllerStore implements ControllerStore {
   updateEffect(options: {
     resourceUid: string;
     key: string;
-    claim: ControllerQueueClaim;
+    claim: ResourceManagerQueueClaim;
     state: EffectRecord["state"];
     externalRef?: string;
     error?: string;
@@ -799,8 +805,8 @@ export class SqliteControllerStore implements ControllerStore {
   }): EffectRecord {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
-      const source = this.requireControllerRowByUid(options.resourceUid);
-      this.assertControllerClaim(source, options.claim, now);
+      const source = this.requireResourceManagerRowByUid(options.resourceUid);
+      this.assertResourceManagerClaim(source, options.claim, now);
       const row = this.requireEffectRow(options.resourceUid, options.key);
       const effectResourceId = resourceIdFor("effect", row.effectId);
       const revision = this.resourceRevision(effectResourceId);
@@ -843,15 +849,15 @@ export class SqliteControllerStore implements ControllerStore {
 
   reserveWorkflow(options: {
     resourceUid: string;
-    claim: ControllerQueueClaim;
+    claim: ResourceManagerQueueClaim;
     requestKey: string;
     workflow: string;
     inputFingerprint: string;
   }): WorkflowReservation {
     const now = Date.now();
     return this.state.transaction(() => {
-      const source = this.requireControllerRowByUid(options.resourceUid);
-      this.assertControllerClaim(source, options.claim, now);
+      const source = this.requireResourceManagerRowByUid(options.resourceUid);
+      this.assertResourceManagerClaim(source, options.claim, now);
       const existing = this.workflowRow(options.resourceUid, options.requestKey);
       if (existing !== undefined) {
         if (
@@ -872,7 +878,7 @@ export class SqliteControllerStore implements ControllerStore {
         )
         .run(
           requestId,
-          source.controllerResourceId,
+          source.managedResourceId,
           options.requestKey,
           options.workflow,
           Buffer.from(options.inputFingerprint, "hex"),
@@ -896,13 +902,13 @@ export class SqliteControllerStore implements ControllerStore {
   updateWorkflow(
     requestId: string,
     update: WorkflowRecordUpdate,
-    claim: ControllerQueueClaim,
+    claim: ResourceManagerQueueClaim,
   ): ChildWorkflowRecord {
     const now = Date.now();
     return this.state.transaction(() => {
       const row = this.requireWorkflowRow(requestId);
-      const source = this.requireControllerRowByUid(row.resourceUid);
-      this.assertControllerClaim(source, claim, now);
+      const source = this.requireResourceManagerRowByUid(row.resourceUid);
+      this.assertResourceManagerClaim(source, claim, now);
       const errorHash =
         update.error === undefined || update.error === null
           ? null
@@ -942,7 +948,7 @@ export class SqliteControllerStore implements ControllerStore {
     if (update.runId !== undefined && row.runId !== null && update.runId !== row.runId) {
       throw new Error("Scheduler completion run ID does not match the reserved child run");
     }
-    const source = this.requireControllerRowByUid(row.resourceUid);
+    const source = this.requireResourceManagerRowByUid(row.resourceUid);
     const now = Date.now();
     return this.state.transaction(() => {
       const errorHash =
@@ -993,17 +999,20 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   recordEvent(options: {
-    controller: string;
+    resourceManager: string;
     key: string;
-    claim?: ControllerQueueClaim;
+    claim?: ResourceManagerQueueClaim;
     type: string;
     payload?: JsonObject;
     now?: string;
-  }): ControllerEvent {
+  }): ResourceManagerEvent {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
-      const row = this.requireControllerRow({ controller: options.controller, key: options.key });
-      if (options.claim !== undefined) this.assertControllerClaim(row, options.claim, now);
+      const row = this.requireResourceManagerRow({
+        resourceManager: options.resourceManager,
+        key: options.key,
+      });
+      if (options.claim !== undefined) this.assertResourceManagerClaim(row, options.claim, now);
       const revision = this.resourceRevision(row.resourceId) + 1;
       this.bumpResource(row.resourceId, revision - 1, now);
       const eventId = this.insertEvent(
@@ -1021,11 +1030,11 @@ export class SqliteControllerStore implements ControllerStore {
         .prepare("SELECT event_seq AS seq FROM events WHERE event_id = ?")
         .get(eventId);
       /* istanbul ignore if -- exact schema and internal query shape */
-      if (!isSequenceRow(event)) throw new Error("Controller event was not recorded");
+      if (!isSequenceRow(event)) throw new Error("ResourceManager event was not recorded");
       return {
         seq: event.seq,
         recordedAt: new Date(now).toISOString(),
-        controller: options.controller,
+        resourceManager: options.resourceManager,
         key: options.key,
         type: options.type,
         payload: options.payload ?? {},
@@ -1034,17 +1043,17 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   listEvents(
-    options: { controller?: string; key?: string; limit?: number } = {},
-  ): ControllerEvent[] {
+    options: { resourceManager?: string; key?: string; limit?: number } = {},
+  ): ResourceManagerEvent[] {
     const clauses = ["r.resource_type = 'controller'"];
     const params: unknown[] = [];
     if (this.projectId !== null) {
       clauses.push("c.project_id = ?");
       params.push(this.projectId);
     }
-    if (options.controller !== undefined) {
+    if (options.resourceManager !== undefined) {
       clauses.push("c.controller_name = ?");
-      params.push(options.controller);
+      params.push(options.resourceManager);
     }
     if (options.key !== undefined) {
       clauses.push("c.resource_key = ?");
@@ -1054,7 +1063,7 @@ export class SqliteControllerStore implements ControllerStore {
     const rows = this.state.connection
       .prepare(
         `SELECT e.event_seq AS seq, e.recorded_at AS recordedAt,
-                c.controller_name AS controller, c.resource_key AS resourceKey,
+                c.controller_name AS resourceManager, c.resource_key AS resourceKey,
                 e.event_type AS eventType, e.payload_hash AS payloadHash
          FROM events e
          JOIN resources r ON r.resource_id = e.resource_id
@@ -1063,10 +1072,10 @@ export class SqliteControllerStore implements ControllerStore {
          ORDER BY e.event_seq DESC LIMIT ?`,
       )
       .all(...params);
-    return rows.filter(isControllerEventRow).map((row) => ({
+    return rows.filter(isResourceManagerEventRow).map((row) => ({
       seq: row.seq,
       recordedAt: new Date(row.recordedAt).toISOString(),
-      controller: row.controller,
+      resourceManager: row.resourceManager,
       key: row.resourceKey,
       type: row.eventType,
       payload: row.payloadHash === null ? {} : (this.state.readJson(row.payloadHash) as JsonObject),
@@ -1403,7 +1412,7 @@ export class SqliteControllerStore implements ControllerStore {
     return this.claimRun(options.runId, options.runnerId, options.claimToken, options.leaseMs, now);
   }
 
-  /** Schedule a worker that validates one pending interactive submission. */
+  /** Schedule a runner that validates one pending interactive submission. */
   claimWorkflowRunForInteractionValidation(options: {
     runId: string;
     runnerId: string;
@@ -1424,7 +1433,7 @@ export class SqliteControllerStore implements ControllerStore {
     );
   }
 
-  /** Take a short host claim without scheduling a parked interactive run. */
+  /** Take a short server claim without scheduling a parked interactive run. */
   claimWorkflowRunForControl(options: {
     runId: string;
     runnerId: string;
@@ -1556,7 +1565,7 @@ export class SqliteControllerStore implements ControllerStore {
       "(q.affinity_runner_id IS NULL OR q.affinity_runner_id = ? OR q.status IN ('parked', 'starting', 'running'))",
       "NOT (q.status = 'parked' AND (r.status = 'waiting' OR r.paused = 1))",
       "NOT EXISTS (SELECT 1 FROM interactive_requests i WHERE i.run_id = r.run_id AND i.status = 'pending')",
-      "(q.error_code IS NULL OR q.error_code <> 'workflowSourceChanged')",
+      "(q.error_code IS NULL OR q.error_code NOT IN ('workflowSourceChanged', 'runnerNoProgress'))",
     ];
     const params: unknown[] = [now, now, options.runnerId, options.runnerId];
     if (this.projectId !== null) {
@@ -1669,6 +1678,78 @@ export class SqliteControllerStore implements ControllerStore {
     return this.releaseRunClaim(options.runId, options.claimToken, "parked", options.now);
   }
 
+  parkWorkflowRunForRunnerNoProgress(options: {
+    runId: string;
+    claimToken: string;
+    detail: string;
+    now?: string;
+  }): boolean {
+    const now = epoch(validTimestamp(options.now));
+    return this.state.transaction(() => {
+      if (
+        !this.verifyWorkflowRunClaim({
+          runId: options.runId,
+          claimToken: options.claimToken,
+          now: new Date(now).toISOString(),
+        })
+      ) {
+        return false;
+      }
+      const row = this.requireWorkflowRunRow(options.runId);
+      const lease = this.requireLease(row.resourceId);
+      const detail = options.detail.slice(0, 8_192);
+      const errorHash = this.state.putText(detail, now);
+      const run = this.state.connection
+        .prepare(
+          `UPDATE runs SET status_detail = ?, updated_at = ?, finished_at = NULL
+           WHERE run_id = ? AND status NOT IN ('completed', 'failed', 'timed_out', 'cancelled')`,
+        )
+        .run(detail, now, options.runId);
+      const queue = this.state.connection
+        .prepare(
+          `UPDATE run_queue
+           SET status = 'parked', error_code = 'runnerNoProgress', error_hash = ?,
+               available_at = ?, updated_at = ?, finished_at = NULL
+           WHERE run_id = ? AND status IN ('queued', 'starting', 'running', 'parked')`,
+        )
+        .run(errorHash, now, now, options.runId);
+      if (run.changes !== 1 || queue.changes !== 1) {
+        throw new Error(`Workflow run ${options.runId} changed during runner recovery`);
+      }
+      const released = this.state.connection
+        .prepare(
+          `UPDATE leases
+           SET owner_type = NULL, owner_id = NULL, token_hash = NULL,
+               acquired_at = NULL, heartbeat_at = NULL, expires_at = NULL
+           WHERE resource_id = ? AND token_hash = ? AND generation = ? AND expires_at > ?`,
+        )
+        .run(row.resourceId, tokenHash(options.claimToken), lease.generation, now);
+      /* istanbul ignore if -- the exact live claim is stable in this transaction */
+      if (released.changes !== 1) {
+        throw new Error(`Workflow run ${options.runId} claim changed during runner recovery`);
+      }
+      const revision = this.resourceRevision(row.resourceId);
+      this.bumpResource(row.resourceId, revision, now);
+      this.insertEvent(
+        row.resourceId,
+        revision + 1,
+        "run.worker_no_progress",
+        lease.ownerType ?? "system",
+        lease.ownerId,
+        { status: "parked", code: "runnerNoProgress" },
+        now,
+        lease.generation || undefined,
+      );
+      recordViewerDeltas(
+        this.state,
+        options.runId,
+        [{ targetType: "summary" }, { targetType: "replay" }],
+        now,
+      );
+      return true;
+    });
+  }
+
   pauseParkedWorkflowRun(options: { runId: string; now?: string }): boolean {
     const now = epoch(validTimestamp(options.now));
     return this.state.transaction(() => {
@@ -2015,6 +2096,7 @@ export class SqliteControllerStore implements ControllerStore {
       if (run.changes !== 1) {
         throw new Error(`Workflow run ${options.runId} has inconsistent durable state`);
       }
+      this.settleWorkflowRunMessages(options.runId, now);
       this.cancelWorkflowRunDependents(options.runId, controlId, errorHash, now);
 
       const released = this.state.connection
@@ -2216,84 +2298,87 @@ export class SqliteControllerStore implements ControllerStore {
 
   private requireProjectId(): string {
     if (this.projectId === null)
-      throw new Error("Controller project is not registered in the state database");
+      throw new Error("ResourceManager project is not registered in the state database");
     return this.projectId;
   }
 
-  private controllerRow(ref: ControllerResourceRef): ControllerRow | undefined {
+  private resourceManagerRow(ref: ManagedResourceRef): ResourceManagerRow | undefined {
     if (this.projectId === null) return undefined;
     const row = this.state.connection
       .prepare(
-        controllerSelect("WHERE c.project_id = ? AND c.controller_name = ? AND c.resource_key = ?"),
+        resourceManagerSelect(
+          "WHERE c.project_id = ? AND c.controller_name = ? AND c.resource_key = ?",
+        ),
       )
-      .get(this.projectId, ref.controller, ref.key);
-    return isControllerRow(row) ? row : undefined;
+      .get(this.projectId, ref.resourceManager, ref.key);
+    return isResourceManagerRow(row) ? row : undefined;
   }
 
-  private requireControllerRow(ref: ControllerResourceRef): ControllerRow {
-    const row = this.controllerRow(ref);
-    if (row === undefined) throw new ResourceNotFoundError(ref.controller, ref.key);
+  private requireResourceManagerRow(ref: ManagedResourceRef): ResourceManagerRow {
+    const row = this.resourceManagerRow(ref);
+    if (row === undefined) throw new ManagedResourceNotFoundError(ref.resourceManager, ref.key);
     return row;
   }
 
-  private requireControllerRowByUid(uid: string): ControllerRow {
-    const row = this.state.connection.prepare(controllerSelect("WHERE c.uid = ?")).get(uid);
+  private requireResourceManagerRowByUid(uid: string): ResourceManagerRow {
+    const row = this.state.connection.prepare(resourceManagerSelect("WHERE c.uid = ?")).get(uid);
     /* istanbul ignore if -- impossible after exact schema and transaction checks */
-    if (!isControllerRow(row)) throw new Error(`Controller resource not found: ${uid}`);
+    if (!isResourceManagerRow(row)) throw new Error(`Managed resource not found: ${uid}`);
     return row;
   }
 
-  private requireResource(ref: ControllerResourceRef): ControllerResource {
+  private requireResource(ref: ManagedResourceRef): ManagedResource {
     const resource = this.getResource(ref);
-    if (resource === undefined) throw new ResourceNotFoundError(ref.controller, ref.key);
+    if (resource === undefined)
+      throw new ManagedResourceNotFoundError(ref.resourceManager, ref.key);
     return resource;
   }
 
   /* istanbul ignore next -- pure projection covered by integration tests */
-  private mapControllerResource(row: ControllerRow): ControllerResource {
+  private mapManagedResource(row: ResourceManagerRow): ManagedResource {
     const spec = this.state.readJson(row.specHash);
-    const status = this.state.readJson(row.statusHash) as ControllerResourceStatus<unknown>;
+    const status = this.state.readJson(row.statusHash) as ManagedResourceStatus<unknown>;
     return {
       metadata: {
         uid: row.uid,
-        controller: row.controllerName,
+        resourceManager: row.resourceManagerName,
         key: row.resourceKey,
         resourceVersion: row.resourceVersion,
         generation: row.generation,
         ...(row.deletionRequestedAt === null
           ? {}
           : { deletionTimestamp: new Date(row.deletionRequestedAt).toISOString() }),
-        finalizers: this.finalizers(row.controllerResourceId),
+        finalizers: this.finalizers(row.managedResourceId),
       },
       spec,
       status,
     };
   }
 
-  private finalizers(controllerResourceId: string): string[] {
+  private finalizers(managedResourceId: string): string[] {
     const rows = this.state.connection
       .prepare(
         "SELECT finalizer FROM controller_finalizers WHERE controller_resource_id = ? ORDER BY position",
       )
-      .all(controllerResourceId);
+      .all(managedResourceId);
     return rows.flatMap((row) => (isFinalizerRow(row) ? [row.finalizer] : []));
   }
 
-  private replaceFinalizers(controllerResourceId: string, finalizers: string[]): void {
+  private replaceFinalizers(managedResourceId: string, finalizers: string[]): void {
     const unique = [...new Set(finalizers)];
     if (unique.length !== finalizers.length)
-      throw new Error("Controller finalizers must be unique");
+      throw new Error("ResourceManager finalizers must be unique");
     this.state.connection
       .prepare("DELETE FROM controller_finalizers WHERE controller_resource_id = ?")
-      .run(controllerResourceId);
+      .run(managedResourceId);
     const insert = this.state.connection.prepare(
       "INSERT INTO controller_finalizers(controller_resource_id, finalizer, position) VALUES (?, ?, ?)",
     );
-    unique.forEach((finalizer, index) => insert.run(controllerResourceId, finalizer, index));
+    unique.forEach((finalizer, index) => insert.run(managedResourceId, finalizer, index));
   }
 
-  private enqueueControllerRow(
-    controllerResourceId: string,
+  private enqueueResourceManagerRow(
+    managedResourceId: string,
     availableAt: number,
     now: number,
   ): void {
@@ -2308,50 +2393,53 @@ export class SqliteControllerStore implements ControllerStore {
            queue_version = controller_queue.queue_version + 1,
            updated_at = excluded.updated_at`,
       )
-      .run(controllerResourceId, availableAt, now, now);
+      .run(managedResourceId, availableAt, now, now);
   }
 
-  private queueErrors(controllerResourceId: string): number {
+  private queueErrors(managedResourceId: string): number {
     const row = this.state.connection
       .prepare(
         "SELECT consecutive_errors AS consecutiveErrors FROM controller_queue WHERE controller_resource_id = ?",
       )
-      .get(controllerResourceId);
+      .get(managedResourceId);
     return isErrorCountRow(row) ? row.consecutiveErrors : 0;
   }
 
-  private queueVersion(controllerResourceId: string): number {
+  private queueVersion(managedResourceId: string): number {
     const row = this.state.connection
       .prepare(
         "SELECT queue_version AS queueVersion FROM controller_queue WHERE controller_resource_id = ?",
       )
-      .get(controllerResourceId);
+      .get(managedResourceId);
     /* istanbul ignore if -- exact schema and internal query shape */
     /* istanbul ignore if -- impossible after exact schema and transaction checks */
-    if (!isQueueVersionRow(row)) throw new Error("Controller queue item is missing");
+    if (!isQueueVersionRow(row)) throw new Error("ResourceManager queue item is missing");
     return row.queueVersion;
   }
 
-  private settleControllerClaim(
-    claim: ControllerQueueClaim,
+  private settleResourceManagerClaim(
+    claim: ResourceManagerQueueClaim,
     requeue: QueueRequeueOptions | undefined,
     nowValue?: string,
   ): boolean {
     const now = epoch(validTimestamp(nowValue));
     return this.state.transaction(() => {
-      const row = this.controllerRow({ controller: claim.controller, key: claim.key });
+      const row = this.resourceManagerRow({
+        resourceManager: claim.resourceManager,
+        key: claim.key,
+      });
       if (row === undefined) return false;
       try {
-        this.assertControllerClaim(row, claim, now, false);
+        this.assertResourceManagerClaim(row, claim, now, false);
       } catch {
         return false;
       }
-      const currentQueueVersion = this.queueVersion(row.controllerResourceId);
+      const currentQueueVersion = this.queueVersion(row.managedResourceId);
       if (requeue === undefined) {
         if (currentQueueVersion === claim.queueVersion) {
           this.state.connection
             .prepare("DELETE FROM controller_queue WHERE controller_resource_id = ?")
-            .run(row.controllerResourceId);
+            .run(row.managedResourceId);
         }
       } else {
         const errorHash =
@@ -2363,21 +2451,21 @@ export class SqliteControllerStore implements ControllerStore {
                  consecutive_errors = consecutive_errors + 1,
                  last_error_hash = ?, updated_at = ? WHERE controller_resource_id = ?`,
           )
-          .run(epoch(requeue.availableAt), errorHash, now, row.controllerResourceId);
+          .run(epoch(requeue.availableAt), errorHash, now, row.managedResourceId);
       }
       this.releaseLease(row.resourceId, claim, now);
       return true;
     });
   }
 
-  private assertControllerClaim(
-    row: ControllerRow,
-    claim: ControllerQueueClaim,
+  private assertResourceManagerClaim(
+    row: ResourceManagerRow,
+    claim: ResourceManagerQueueClaim,
     now: number,
     requireUnexpired = true,
   ): void {
-    if (row.controllerName !== claim.controller || row.resourceKey !== claim.key)
-      throw new Error("Controller claim targets another resource");
+    if (row.resourceManagerName !== claim.resourceManager || row.resourceKey !== claim.key)
+      throw new Error("ResourceManager claim targets another resource");
     const lease = this.requireLease(row.resourceId);
     if (
       lease.ownerType !== "controller" ||
@@ -2387,7 +2475,7 @@ export class SqliteControllerStore implements ControllerStore {
       !lease.tokenHash.equals(tokenHash(claim.token)) ||
       (requireUnexpired && (lease.expiresAt === null || lease.expiresAt <= now))
     ) {
-      throw new Error("Controller claim is stale");
+      throw new Error("ResourceManager claim is stale");
     }
   }
 
@@ -2405,8 +2493,8 @@ export class SqliteControllerStore implements ControllerStore {
     return row;
   }
 
-  private releaseLease(resourceId: string, claim: ControllerQueueClaim, now: number): void {
-    const row = this.controllerRow({ controller: claim.controller, key: claim.key });
+  private releaseLease(resourceId: string, claim: ResourceManagerQueueClaim, now: number): void {
+    const row = this.resourceManagerRow({ resourceManager: claim.resourceManager, key: claim.key });
     if (row === undefined) return;
     const revision = this.resourceRevision(resourceId);
     const result = this.state.connection
@@ -2524,7 +2612,7 @@ export class SqliteControllerStore implements ControllerStore {
       resourceUid: row.resourceUid,
       generation: row.generation,
       kind: row.kind,
-      state: controllerEffectState(row.state),
+      state: resourceManagerEffectState(row.state),
       requestFingerprint: row.requestFingerprint,
       startedAt: new Date(row.startedAt).toISOString(),
       ...(row.completedAt === null ? {} : { completedAt: new Date(row.completedAt).toISOString() }),
@@ -2924,6 +3012,7 @@ export class SqliteControllerStore implements ControllerStore {
            WHERE run_id = ?`,
         )
         .run(status, errorHash, now, now, runId);
+      this.settleWorkflowRunMessages(runId, now);
       if (status === "cancelled") {
         this.cancelWorkflowRunDependents(
           runId,
@@ -2953,6 +3042,11 @@ export class SqliteControllerStore implements ControllerStore {
     });
   }
 
+  private settleWorkflowRunMessages(runId: string, now: number): void {
+    this.workflowMessages.settleOpenTurnsForRun(runId, "lost", now);
+    this.workflowMessages.cancelPendingForRun(runId, now);
+  }
+
   private cancelWorkflowRunDependents(
     runId: string,
     actorId: string,
@@ -3047,14 +3141,14 @@ export class SqliteControllerStore implements ControllerStore {
   }
 
   private assertWritable(): void {
-    if (this.state.mode === "read-only") throw new Error("Controller store is read-only");
+    if (this.state.mode === "read-only") throw new Error("ResourceManager store is read-only");
   }
 }
 
-function controllerSelect(clause: string): string {
-  return `SELECT c.controller_resource_id AS controllerResourceId,
+function resourceManagerSelect(clause: string): string {
+  return `SELECT c.controller_resource_id AS managedResourceId,
     c.resource_id AS resourceId, r.revision AS resourceVersion,
-    c.controller_name AS controllerName, c.resource_key AS resourceKey,
+    c.controller_name AS resourceManagerName, c.resource_key AS resourceKey,
     c.uid, c.generation, c.spec_hash AS specHash, c.status_hash AS statusHash,
     c.deletion_requested_at AS deletionRequestedAt
     FROM controller_resources c JOIN resources r ON r.resource_id = c.resource_id ${clause}`;
@@ -3123,16 +3217,16 @@ function workflowRunViewSelect(clause: string): string {
 }
 
 type QueueListRow = {
-  controller: string;
+  resourceManager: string;
   resourceKey: string;
   availableAt: number;
   consecutiveErrors: number;
   claimExpiresAt: number | null;
 };
-type ControllerEventRow = {
+type ResourceManagerEventRow = {
   seq: number;
   recordedAt: number;
-  controller: string;
+  resourceManager: string;
   resourceKey: string;
   eventType: string;
   payloadHash: Buffer | null;
@@ -3149,7 +3243,7 @@ type RunEventRow = {
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isControllerRow(value: unknown): value is ControllerRow {
+function isResourceManagerRow(value: unknown): value is ResourceManagerRow {
   return isRecord(value);
 }
 function isLeaseRow(value: unknown): value is LeaseRow {
@@ -3256,7 +3350,7 @@ function isWorkflowRow(value: unknown): value is WorkflowRow {
 function isQueueListRow(value: unknown): value is QueueListRow {
   return isRecord(value);
 }
-function isControllerEventRow(value: unknown): value is ControllerEventRow {
+function isResourceManagerEventRow(value: unknown): value is ResourceManagerEventRow {
   return isRecord(value);
 }
 function isRunEventRow(value: unknown): value is RunEventRow {
@@ -3436,7 +3530,7 @@ function rowToSource(row: RunSourceIdentityRow): QueuedSource["root"] {
 function effectStatus(value: EffectRecord["state"]): string {
   return value === "indeterminate" ? "ambiguous" : value;
 }
-function controllerEffectState(value: string): EffectRecord["state"] {
+function resourceManagerEffectState(value: string): EffectRecord["state"] {
   return value === "ambiguous" ? "indeterminate" : (value as EffectRecord["state"]);
 }
 function validTimestamp(value?: string): string {