@osolmaz/pi-workflows 0.15.3 → 0.16.1

package/src/host/worker-protocol.ts

@@ -1,5 +1,5 @@
+import { MAX_PROTOCOL_MESSAGE_BYTES } from "../client/protocol.js";
 import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
-import { MAX_PROTOCOL_MESSAGE_BYTES } from "./protocol.js";
 
 export const WORKER_MESSAGE_SCHEMA = "pi-workflows.worker-message.v1" as const;
 export const WORKER_RESPONSE_SCHEMA = "pi-workflows.worker-response.v1" as const;

package/src/state/database.ts

@@ -110,6 +110,19 @@ export class StateDatabase {
     this.connection.close();
   }
 
+  readTransaction<T>(operation: () => T): T {
+    if (this.connection.inTransaction) return operation();
+    this.connection.exec("BEGIN");
+    try {
+      const result = operation();
+      this.connection.exec("COMMIT");
+      return result;
+    } catch (error) {
+      if (this.connection.inTransaction) this.connection.exec("ROLLBACK");
+      throw error;
+    }
+  }
+
   transaction<T>(operation: () => T): T {
     if (this.mode === "read-only") {
       throw new Error("Cannot mutate a read-only Pi Workflows database");

package/src/state/prune.ts

@@ -34,25 +34,26 @@ export type StatePruneReport = {
   applied: boolean;
 };
 
-export async function pruneState(
-  databasePath: string,
-  options: StatePruneOptions,
-): Promise<StatePruneReport> {
-  const cutoff = parseCutoff(options.before);
+export function validateStatePruneOptions(options: StatePruneOptions): void {
+  parseCutoff(options.before);
   if (options.apply && options.backupPath === undefined) {
     throw new Error("state prune --apply requires --backup <absolute-path>");
   }
   if (options.backupPath !== undefined && !path.isAbsolute(options.backupPath)) {
     throw new Error("state prune backup path must be absolute");
   }
+}
+
+export async function pruneState(
+  state: StateDatabase,
+  databasePath: string,
+  options: StatePruneOptions,
+): Promise<StatePruneReport> {
+  validateStatePruneOptions(options);
+  const cutoff = parseCutoff(options.before);
   const lockPath = `${databasePath}.maintenance.lock`;
   const lock = options.apply ? acquireMaintenanceLock(lockPath) : undefined;
-  let state: StateDatabase | undefined;
   try {
-    state = new StateDatabase({
-      filePath: databasePath,
-      mode: options.apply ? "read-write" : "read-only",
-    });
     const selection = selectRunTrees(state, cutoff);
     const sizeBefore = databaseBytes(databasePath);
     const base = {
@@ -136,7 +137,6 @@ export async function pruneState(
       applied: true,
     };
   } finally {
-    state?.close();
     if (lock !== undefined) releaseMaintenanceLock(lockPath, lock);
   }
 }
@@ -215,13 +215,7 @@ function treeHasBlocker(database: Database.Database, runIds: string[]): boolean
     hasRow(
       database,
       `SELECT 1 FROM workflow_follow_ups
-       WHERE run_id IN (${values}) AND status IN ('queued', 'pending_presentation', 'ready')`,
-      runIds,
-    ) ||
-    hasRow(
-      database,
-      `SELECT 1 FROM workflow_follow_up_queues
-       WHERE run_id IN (${values}) AND presentation_state = 'pending'`,
+       WHERE run_id IN (${values}) AND status = 'queued'`,
       runIds,
     ) ||
     hasRow(
@@ -294,15 +288,8 @@ function deleteRunAggregates(database: Database.Database, runIds: string[]): voi
   const effectIds = effectRows.map((row) => row.effectId);
   if (effectIds.length !== 0) {
     const effectValues = placeholders(effectIds);
-    database
-      .prepare(`DELETE FROM notifications WHERE effect_id IN (${effectValues})`)
-      .run(...effectIds);
-    database
-      .prepare(`DELETE FROM turn_intents WHERE effect_id IN (${effectValues})`)
-      .run(...effectIds);
     database.prepare(`DELETE FROM effects WHERE effect_id IN (${effectValues})`).run(...effectIds);
   }
-  database.prepare(`DELETE FROM turn_intents WHERE run_id IN (${values})`).run(...runIds);
   database
     .prepare(
       `DELETE FROM continuations
@@ -331,13 +318,11 @@ function relatedResourceIds(database: Database.Database, runIds: string[]): stri
       `SELECT resource_id AS resourceId FROM runs WHERE run_id IN (${values})
        UNION SELECT resource_id FROM session_segments WHERE run_id IN (${values})
        UNION SELECT resource_id FROM human_decisions WHERE run_id IN (${values})
-       UNION SELECT resource_id FROM turn_intents WHERE run_id IN (${values})
        UNION SELECT resource_id FROM workflow_settings
          WHERE origin_run_id IN (${values}) OR active_run_id IN (${values})
-       UNION SELECT resource_id FROM workflow_follow_up_queues WHERE run_id IN (${values})
        UNION SELECT resource_id FROM workflow_follow_ups WHERE run_id IN (${values})`,
     )
-    .all(...runIds, ...runIds, ...runIds, ...runIds, ...runIds, ...runIds, ...runIds, ...runIds)
+    .all(...runIds, ...runIds, ...runIds, ...runIds, ...runIds, ...runIds)
     .filter(isResourceRow);
   const resources = rows.map((row) => row.resourceId);
   if (resources.length === 0) return [];
@@ -349,20 +334,7 @@ function relatedResourceIds(database: Database.Database, runIds: string[]): stri
     .all(...resources)
     .filter(isResourceRow)
     .map((row) => row.resourceId);
-  const notificationResources = database
-    .prepare(
-      `SELECT resource.resource_id AS resourceId
-       FROM notifications notification
-       JOIN effects effect ON effect.effect_id = notification.effect_id
-       JOIN resources resource
-         ON resource.resource_type = 'notification'
-        AND resource.aggregate_key = notification.notification_id
-       WHERE effect.source_resource_id IN (${placeholders(resources)})`,
-    )
-    .all(...resources)
-    .filter(isResourceRow)
-    .map((row) => row.resourceId);
-  return [...new Set([...resources, ...effectResources, ...notificationResources])];
+  return [...new Set([...resources, ...effectResources])];
 }
 
 function selectionSignature(database: Database.Database, runIds: string[]): string {

package/src/state/schema.ts

@@ -56,8 +56,7 @@ CREATE TABLE blobs (
 CREATE TABLE resources (
   resource_id TEXT PRIMARY KEY,
   resource_type TEXT NOT NULL CHECK (resource_type IN (
-    'run', 'session', 'decision', 'controller', 'effect', 'channel', 'notification', 'turn_intent',
-    'settings', 'follow_up_queue', 'follow_up'
+    'run', 'session', 'decision', 'controller', 'effect', 'channel', 'settings', 'follow_up'
   )),
   aggregate_key TEXT NOT NULL,
   revision INTEGER NOT NULL DEFAULT 0 CHECK (revision >= 0),
@@ -115,6 +114,12 @@ CREATE TABLE runs (
   resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id) ON DELETE CASCADE,
   project_id TEXT REFERENCES projects(project_id),
   parent_run_id TEXT REFERENCES runs(run_id),
+  root_run_id TEXT NOT NULL REFERENCES runs(run_id),
+  lineage_kind TEXT CHECK (lineage_kind IS NULL OR lineage_kind IN ('continuation', 'restart')),
+  restart_number INTEGER NOT NULL DEFAULT 0 CHECK (restart_number >= 0),
+  parent_terminal_fingerprint BLOB CHECK (
+    parent_terminal_fingerprint IS NULL OR length(parent_terminal_fingerprint) = 32
+  ),
   definition_digest BLOB NOT NULL REFERENCES workflow_definitions(definition_digest),
   workflow_ref TEXT NOT NULL,
   launch_options_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
@@ -127,15 +132,35 @@ CREATE TABLE runs (
   input_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
   final_output_hash BLOB REFERENCES blobs(blob_hash),
   error_hash BLOB REFERENCES blobs(blob_hash),
+  presentation_prompt_hash BLOB REFERENCES blobs(blob_hash),
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
   finished_at INTEGER,
-  CHECK ((status IN ('waiting', 'completed', 'failed', 'timed_out', 'cancelled')) = (finished_at IS NOT NULL))
+  CHECK ((status IN ('waiting', 'completed', 'failed', 'timed_out', 'cancelled')) = (finished_at IS NOT NULL)),
+  CHECK ((parent_run_id IS NULL) = (lineage_kind IS NULL)),
+  CHECK (
+    (lineage_kind = 'restart' AND parent_terminal_fingerprint IS NOT NULL) OR
+    (lineage_kind IS NOT 'restart' AND parent_terminal_fingerprint IS NULL)
+  ),
+  CHECK (parent_run_id IS NOT NULL OR restart_number = 0)
 ) STRICT;
 
 CREATE INDEX runs_project_idx ON runs(project_id, created_at DESC);
 CREATE INDEX runs_status_idx ON runs(status, updated_at DESC);
 CREATE INDEX runs_parent_idx ON runs(parent_run_id);
+CREATE UNIQUE INDEX runs_restart_parent_idx ON runs(parent_run_id)
+  WHERE lineage_kind = 'restart';
+
+CREATE TABLE run_view_content (
+  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+  content_hash BLOB NOT NULL,
+  media_type TEXT NOT NULL CHECK (media_type IN ('application/json', 'text/plain')),
+  byte_length INTEGER NOT NULL CHECK (byte_length >= 0),
+  content BLOB NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (run_id, content_hash, media_type),
+  CHECK (byte_length = length(content))
+) STRICT;
 
 CREATE TABLE viewer_runs (
   run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
@@ -222,33 +247,10 @@ CREATE TABLE workflow_setting_changes (
   UNIQUE (scope_id, change_number)
 ) STRICT;
 
-CREATE TABLE workflow_follow_up_queues (
-  run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
-  resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id) ON DELETE CASCADE,
-  origin_session_id TEXT,
-  presentation_state TEXT NOT NULL DEFAULT 'none' CHECK (presentation_state IN (
-    'none', 'not-needed', 'pending', 'settled', 'unavailable'
-  )),
-  presentation_entry_id TEXT,
-  presentation_assistant_entry_id TEXT,
-  presentation_reason_hash BLOB REFERENCES blobs(blob_hash),
-  presentation_updated_at INTEGER,
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL,
-  CHECK (
-    (presentation_state IN ('none', 'not-needed', 'pending') AND presentation_assistant_entry_id IS NULL AND presentation_reason_hash IS NULL)
-    OR
-    (presentation_state = 'unavailable' AND presentation_assistant_entry_id IS NULL AND presentation_reason_hash IS NOT NULL)
-    OR
-    (presentation_state = 'settled' AND presentation_entry_id IS NOT NULL AND presentation_assistant_entry_id IS NOT NULL AND presentation_reason_hash IS NULL)
-  )
-) STRICT;
-
 CREATE TABLE workflow_follow_ups (
   follow_up_id TEXT PRIMARY KEY,
   resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id) ON DELETE CASCADE,
-  queue_resource_id TEXT NOT NULL REFERENCES resources(resource_id),
-  run_id TEXT NOT NULL REFERENCES workflow_follow_up_queues(run_id) ON DELETE CASCADE,
+  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
   request_id TEXT NOT NULL,
   order_number INTEGER NOT NULL CHECK (order_number > 0),
   target_session_id TEXT NOT NULL,
@@ -258,21 +260,17 @@ CREATE TABLE workflow_follow_ups (
   actor_id TEXT,
   source_type TEXT NOT NULL,
   prompt_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  status TEXT NOT NULL CHECK (status IN (
-    'queued', 'pending_presentation', 'ready', 'sent', 'removed', 'cancelled'
-  )),
-  session_entry_id TEXT,
+  status TEXT NOT NULL CHECK (status IN ('queued', 'removed', 'cancelled')),
   reason_hash BLOB REFERENCES blobs(blob_hash),
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
-  sent_at INTEGER,
   UNIQUE (run_id, request_id),
   UNIQUE (run_id, order_number),
-  CHECK ((status = 'sent') = (session_entry_id IS NOT NULL AND sent_at IS NOT NULL)),
   CHECK ((status IN ('removed', 'cancelled')) = (reason_hash IS NOT NULL))
 ) STRICT;
 
-CREATE INDEX workflow_follow_ups_delivery_idx ON workflow_follow_ups(target_session_id, status, order_number);
+CREATE INDEX workflow_follow_ups_order_idx
+  ON workflow_follow_ups(target_session_id, run_id, order_number);
 
 CREATE TABLE run_queue (
   run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
@@ -301,9 +299,11 @@ CREATE TABLE host_commands (
   operation TEXT NOT NULL CHECK (operation IN (
     'run.start', 'run.pause', 'run.resume', 'run.cancel', 'run.status', 'run.list',
     'checkpoint.answer', 'decision.answer', 'interaction.submit', 'interaction.update',
-    'notification.claim', 'notification.deliver', 'turn.claim', 'turn.resolve',
+    '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'
+    'host.status', 'host.stop', 'state.backup', 'state.prune'
   )),
   idempotency_key TEXT NOT NULL,
   request_fingerprint BLOB NOT NULL CHECK (length(request_fingerprint) = 32),
@@ -507,24 +507,70 @@ CREATE TABLE interactive_requests (
   kind TEXT NOT NULL CHECK (kind IN ('agent', 'assistant', 'decision')),
   contract_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
   revision INTEGER NOT NULL DEFAULT 1 CHECK (revision > 0),
-  status TEXT NOT NULL CHECK (status IN ('pending', 'presenting', 'settled', 'cancelled')),
-  presenter_id TEXT,
-  presentation_claim_expires_at INTEGER,
-  presentation_session_entry_id TEXT,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'settled', 'cancelled')),
+  unproductive_turn_ends INTEGER NOT NULL DEFAULT 0 CHECK (unproductive_turn_ends >= 0),
   accepted_submission_id TEXT,
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
   settled_at INTEGER,
   consumed_at INTEGER,
   CHECK ((status = 'settled') = (accepted_submission_id IS NOT NULL AND settled_at IS NOT NULL)),
-  CHECK ((presenter_id IS NULL) = (presentation_claim_expires_at IS NULL)),
-  CHECK (presenter_id IS NULL OR status = 'presenting'),
   CHECK (consumed_at IS NULL OR status = 'settled')
 ) STRICT;
 
 CREATE INDEX interactive_requests_session_idx
   ON interactive_requests(target_session_id, status, created_at);
 
+CREATE TABLE workflow_messages (
+  workflow_message_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+  target_session_id TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('step', 'decision', 'notification', 'terminal', 'followUp')),
+  source_id TEXT NOT NULL,
+  content_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
+  order_number INTEGER NOT NULL CHECK (order_number > 0),
+  status TEXT NOT NULL CHECK (status IN ('pending', 'sent', 'cancelled')),
+  pi_session_entry_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE (target_session_id, order_number),
+  CHECK ((status = 'sent') = (pi_session_entry_id IS NOT NULL))
+) STRICT;
+
+CREATE INDEX workflow_messages_session_idx
+  ON workflow_messages(target_session_id, status, order_number);
+CREATE INDEX workflow_messages_run_idx ON workflow_messages(run_id, order_number);
+CREATE INDEX workflow_messages_source_idx ON workflow_messages(kind, source_id, order_number);
+CREATE UNIQUE INDEX workflow_messages_pending_step_source_idx
+  ON workflow_messages(source_id) WHERE kind = 'step' AND status = 'pending';
+
+CREATE TABLE workflow_turns (
+  workflow_turn_id TEXT PRIMARY KEY,
+  workflow_message_id TEXT NOT NULL REFERENCES workflow_messages(workflow_message_id) ON DELETE CASCADE,
+  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+  target_session_id TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('started', 'ended')),
+  stop_reason TEXT CHECK (stop_reason IS NULL OR stop_reason IN ('completed', 'aborted', 'error', 'lost')),
+  response_session_entry_id TEXT,
+  started_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  CHECK (
+    (state = 'started' AND stop_reason IS NULL AND ended_at IS NULL)
+    OR
+    (state = 'ended' AND stop_reason IS NOT NULL AND ended_at IS NOT NULL)
+  )
+) STRICT;
+
+CREATE UNIQUE INDEX workflow_turns_open_message_idx
+  ON workflow_turns(workflow_message_id) WHERE state = 'started';
+CREATE INDEX workflow_turns_session_idx ON workflow_turns(target_session_id, state, started_at);
+
+CREATE TABLE session_terminal_views (
+  target_session_id TEXT PRIMARY KEY,
+  cleared_run_id TEXT REFERENCES runs(run_id) ON DELETE SET NULL,
+  cleared_at INTEGER NOT NULL
+) STRICT;
+
 CREATE TABLE interactive_submissions (
   submission_id TEXT PRIMARY KEY,
   request_id TEXT NOT NULL REFERENCES interactive_requests(request_id) ON DELETE CASCADE,
@@ -670,39 +716,6 @@ CREATE TABLE effect_attempts (
   PRIMARY KEY (effect_id, attempt_number)
 ) STRICT;
 
-CREATE TABLE notifications (
-  notification_id TEXT PRIMARY KEY,
-  effect_id TEXT NOT NULL UNIQUE REFERENCES effects(effect_id),
-  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-  attempt_id TEXT NOT NULL REFERENCES node_attempts(attempt_id),
-  notification_index INTEGER NOT NULL CHECK (notification_index >= 0),
-  target_session_id TEXT NOT NULL,
-  notification_type TEXT NOT NULL CHECK (notification_type IN ('progress', 'final')),
-  content_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  created_at INTEGER NOT NULL,
-  UNIQUE (run_id, attempt_id, notification_index)
-) STRICT;
-
-CREATE TABLE turn_intents (
-  turn_intent_id TEXT PRIMARY KEY,
-  resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id),
-  effect_id TEXT NOT NULL UNIQUE REFERENCES effects(effect_id),
-  source_event_id TEXT NOT NULL UNIQUE,
-  run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-  workflow_ref TEXT NOT NULL,
-  target_session_id TEXT NOT NULL,
-  cause TEXT NOT NULL,
-  node_id TEXT,
-  attempt_id TEXT,
-  resolution_type TEXT,
-  resolution_message_id TEXT,
-  facts_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  requested_at INTEGER NOT NULL,
-  eligible_at INTEGER,
-  resolved_at INTEGER,
-  created_at INTEGER NOT NULL
-) STRICT;
-
 CREATE TABLE channels (
   channel_id TEXT PRIMARY KEY,
   resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id),
@@ -720,41 +733,18 @@ CREATE TABLE channel_cursors (
   PRIMARY KEY (channel_id, cursor_key)
 ) STRICT;
 
-CREATE TABLE channel_inbox (
-  channel_id TEXT NOT NULL REFERENCES channels(channel_id) ON DELETE CASCADE,
-  external_event_id TEXT NOT NULL,
-  event_type TEXT NOT NULL CHECK (event_type IN ('callback', 'reply')),
-  payload_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  received_at INTEGER NOT NULL,
-  processed_at INTEGER,
-  result_hash BLOB REFERENCES blobs(blob_hash),
-  PRIMARY KEY (channel_id, external_event_id)
-) STRICT;
-
 CREATE TABLE channel_messages (
   message_id TEXT PRIMARY KEY,
   channel_id TEXT NOT NULL REFERENCES channels(channel_id) ON DELETE CASCADE,
   decision_id TEXT REFERENCES human_decisions(decision_id),
   purpose TEXT NOT NULL CHECK (purpose IN ('delivery', 'settlement')),
   content_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  external_conversation_ref TEXT,
-  external_message_ref TEXT,
   status TEXT NOT NULL CHECK (status IN ('pending', 'confirmed', 'failed', 'ambiguous')),
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL
 ) STRICT;
 
 CREATE INDEX channel_messages_decision_idx ON channel_messages(decision_id, purpose, created_at);
-
-CREATE TABLE channel_message_parts (
-  message_id TEXT NOT NULL REFERENCES channel_messages(message_id) ON DELETE CASCADE,
-  recipient_index INTEGER NOT NULL CHECK (recipient_index >= 0),
-  part_index INTEGER NOT NULL CHECK (part_index >= 0),
-  content_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  external_conversation_ref TEXT NOT NULL,
-  external_message_ref TEXT NOT NULL,
-  PRIMARY KEY (message_id, recipient_index, part_index)
-) STRICT;
 `;
 
 export const STATE_SCHEMA_DIGEST = createHash("sha256").update(STATE_SCHEMA_SQL).digest();