@osolmaz/pi-workflows 0.16.4 → 0.16.6

package/src/state/schema.ts

@@ -115,11 +115,9 @@ CREATE TABLE runs (
   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')),
+  lineage_kind TEXT CHECK (lineage_kind IS NULL OR lineage_kind IN ('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
-  ),
+  parent_run_revision INTEGER CHECK (parent_run_revision IS NULL OR parent_run_revision >= 0),
   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),
@@ -132,15 +130,14 @@ 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 ('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)
+    (lineage_kind = 'restart' AND parent_run_revision IS NOT NULL) OR
+    (lineage_kind IS NOT 'restart' AND parent_run_revision IS NULL)
   ),
   CHECK (parent_run_id IS NOT NULL OR restart_number = 0)
 ) STRICT;
@@ -278,8 +275,7 @@ CREATE TABLE run_queue (
     'queued', 'starting', 'running', 'parked', 'done', 'failed', 'cancelled'
   )),
   available_at INTEGER NOT NULL,
-  affinity_runner_id TEXT,
-  origin_session_id TEXT NOT NULL,
+  origin_session_id TEXT,
   consecutive_errors INTEGER NOT NULL DEFAULT 0 CHECK (consecutive_errors >= 0),
   error_code TEXT,
   error_hash BLOB REFERENCES blobs(blob_hash),
@@ -291,7 +287,7 @@ CREATE TABLE run_queue (
 
 CREATE INDEX run_queue_claim_idx ON run_queue(status, available_at, created_at);
 CREATE UNIQUE INDEX run_queue_active_session_idx ON run_queue(origin_session_id)
-WHERE status IN ('queued', 'starting', 'running');
+WHERE origin_session_id IS NOT NULL AND status IN ('queued', 'starting', 'running', 'parked');
 
 CREATE TABLE host_commands (
   request_id TEXT PRIMARY KEY,
@@ -377,7 +373,7 @@ CREATE TABLE node_attempts (
   settings_change_number INTEGER CHECK (settings_change_number IS NULL OR settings_change_number >= 0),
   settings_hash BLOB REFERENCES blobs(blob_hash),
   started_at INTEGER,
-  deadline_at INTEGER,
+  timeout_ms REAL CHECK (timeout_ms IS NULL OR timeout_ms >= 0),
   finished_at INTEGER,
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
@@ -387,13 +383,23 @@ CREATE TABLE node_attempts (
 CREATE UNIQUE INDEX node_attempts_active_idx ON node_attempts(run_id)
 WHERE status IN ('pending', 'running', 'waiting');
 CREATE INDEX node_attempts_run_idx ON node_attempts(run_id, created_at);
-CREATE INDEX node_attempts_deadline_idx ON node_attempts(deadline_at) WHERE deadline_at IS NOT NULL;
+-- NULL means not configured; zero is an explicitly unlimited timeout.
+CREATE TABLE attempt_active_intervals (
+  attempt_id TEXT NOT NULL REFERENCES node_attempts(attempt_id) ON DELETE CASCADE,
+  interval_number INTEGER NOT NULL CHECK (interval_number > 0),
+  started_at INTEGER NOT NULL,
+  observed_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  elapsed_ms REAL NOT NULL DEFAULT 0 CHECK (elapsed_ms >= 0),
+  PRIMARY KEY (attempt_id, interval_number)
+) STRICT;
+CREATE UNIQUE INDEX attempt_active_intervals_open_idx ON attempt_active_intervals(attempt_id)
+WHERE ended_at IS NULL;
 
 CREATE TABLE run_steps (
   run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
   step_index INTEGER NOT NULL CHECK (step_index >= 0),
   attempt_id TEXT NOT NULL REFERENCES node_attempts(attempt_id),
-  output_override_hash BLOB REFERENCES blobs(blob_hash),
   PRIMARY KEY (run_id, step_index),
   UNIQUE (run_id, attempt_id)
 ) STRICT;
@@ -504,11 +510,10 @@ CREATE TABLE interactive_requests (
   run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
   attempt_id TEXT NOT NULL UNIQUE REFERENCES node_attempts(attempt_id) ON DELETE CASCADE,
   target_session_id TEXT NOT NULL,
-  kind TEXT NOT NULL CHECK (kind IN ('agent', 'assistant', 'decision')),
+  kind TEXT NOT NULL CHECK (kind IN ('agent', 'assistant', 'checkpoint', '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', '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,
@@ -520,6 +525,8 @@ CREATE TABLE interactive_requests (
 
 CREATE INDEX interactive_requests_session_idx
   ON interactive_requests(target_session_id, status, created_at);
+CREATE UNIQUE INDEX interactive_requests_pending_run_idx
+  ON interactive_requests(run_id) WHERE status = 'pending';
 
 CREATE TABLE workflow_messages (
   workflow_message_id TEXT PRIMARY KEY,
@@ -615,13 +622,6 @@ CREATE TABLE human_decision_submissions (
   PRIMARY KEY (decision_id, attempt_id)
 ) STRICT;
 
-CREATE TABLE continuations (
-  decision_id TEXT PRIMARY KEY REFERENCES human_decisions(decision_id) ON DELETE CASCADE,
-  parent_run_id TEXT NOT NULL UNIQUE REFERENCES runs(run_id),
-  continuation_run_id TEXT NOT NULL UNIQUE REFERENCES runs(run_id),
-  created_at INTEGER NOT NULL
-) STRICT;
-
 CREATE TABLE controller_resources (
   controller_resource_id TEXT PRIMARY KEY,
   resource_id TEXT NOT NULL UNIQUE REFERENCES resources(resource_id) ON DELETE CASCADE,

package/src/state/workflow-messages.ts

@@ -8,7 +8,7 @@ export const WORKFLOW_TURN_SCHEMA = "pi-workflows.workflow-turn.v1" as const;
 
 export type WorkflowMessageKind = "step" | "decision" | "notification" | "terminal" | "followUp";
 export type WorkflowMessageStatus = "pending" | "sent" | "cancelled";
-export type WorkflowStepReason = "initial" | "reminder" | "resumed";
+export type WorkflowStepReason = "initial" | "resumed";
 export type WorkflowTurnState = "started" | "ended";
 export type WorkflowTurnStopReason = "completed" | "aborted" | "error" | "lost";
 
@@ -278,6 +278,8 @@ export class WorkflowMessageStore {
       if (message.runId !== options.runId || message.targetSessionId !== options.targetSessionId) {
         throw new Error("Workflow turn does not match its message");
       }
+      if (!message.content.triggerTurn)
+        throw new Error("Workflow message does not request a model turn");
       if (message.status !== "sent") throw new Error("Workflow turn requires a sent message");
       const open = this.openTurnForMessage(options.workflowMessageId);
       if (open !== undefined) {
@@ -496,7 +498,7 @@ export function isWorkflowMessageContent(value: unknown): value is WorkflowMessa
 
 function validateContent(content: WorkflowMessageContent, kind: WorkflowMessageKind): void {
   if (!isWorkflowMessageContent(content)) throw new Error("Workflow message content is invalid");
-  const shouldTrigger = kind === "step" || kind === "terminal" || kind === "followUp";
+  const shouldTrigger = kind === "step" || kind === "followUp";
   if (content.triggerTurn !== shouldTrigger) {
     throw new Error(`Workflow message kind ${kind} has invalid turn behavior`);
   }

package/src/viewer/backup.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { StateDatabase, workflowStatePath } from "../state/database.js";
+import { workflowStateViolations } from "../workflows/diagnostics.js";
 
 /** Verify only an explicit inactive backup. Active state is verified through WorkflowClient. */
 export function verifyInactiveBackup(
@@ -15,6 +16,12 @@ export function verifyInactiveBackup(
   const state = new StateDatabase({ filePath: resolved, mode: "read-only" });
   try {
     state.integrityCheck();
+    const violations = workflowStateViolations(state);
+    if (violations.length > 0) {
+      throw new Error(
+        violations.map((item) => `${item.code} ${item.runId}: ${item.detail}`).join("\n"),
+      );
+    }
   } finally {
     state.close();
   }

package/src/workflows/diagnostics.ts

@@ -0,0 +1,78 @@
+import type { StateDatabase } from "../state/database.js";
+
+export type WorkflowStateViolation = {
+  code:
+    | "queueState"
+    | "waitingRequest"
+    | "pendingRequest"
+    | "acceptedRequest"
+    | "activeClock"
+    | "sessionTurns";
+  runId: string;
+  detail: string;
+};
+
+/** Inspect domain facts without repairing or reinterpreting durable state. */
+export function workflowStateViolations(state: StateDatabase): WorkflowStateViolation[] {
+  const checks: Array<{ code: WorkflowStateViolation["code"]; detail: string; sql: string }> = [
+    {
+      code: "queueState",
+      detail: "Execution and queue terminal states disagree.",
+      sql: `SELECT r.run_id AS runId FROM runs r JOIN run_queue q ON q.run_id = r.run_id
+        WHERE ((q.status IN ('done', 'failed', 'cancelled')) OR
+          (r.status IN ('completed', 'failed', 'timed_out', 'cancelled') AND NOT EXISTS (
+            SELECT 1 FROM effects e WHERE e.source_resource_id = r.resource_id
+              AND e.effect_type = 'run.settle_queue' AND e.status = 'pending')))
+        AND NOT ((r.status = 'completed' AND q.status = 'done')
+          OR (r.status IN ('failed', 'timed_out') AND q.status = 'failed')
+          OR (r.status = 'cancelled' AND q.status = 'cancelled'))`,
+    },
+    {
+      code: "waitingRequest",
+      detail: "A waiting run has no pending request or unconsumed accepted response.",
+      sql: `SELECT r.run_id AS runId FROM runs r WHERE r.status = 'waiting' AND NOT EXISTS (
+        SELECT 1 FROM interactive_requests i WHERE i.run_id = r.run_id
+          AND (i.status = 'pending' OR (i.status = 'settled' AND i.consumed_at IS NULL)))`,
+    },
+    {
+      code: "pendingRequest",
+      detail: "A pending request has no matching active attempt and live run.",
+      sql: `SELECT i.run_id AS runId FROM interactive_requests i
+        JOIN runs r ON r.run_id = i.run_id JOIN node_attempts a ON a.attempt_id = i.attempt_id
+        WHERE i.status = 'pending' AND (a.run_id <> i.run_id
+          OR a.status NOT IN ('pending', 'running', 'waiting', 'interrupted')
+          OR r.status NOT IN ('running', 'waiting'))`,
+    },
+    {
+      code: "acceptedRequest",
+      detail: "A settled request has no matching accepted submission.",
+      sql: `SELECT i.run_id AS runId FROM interactive_requests i
+        LEFT JOIN interactive_submissions s ON s.submission_id = i.accepted_submission_id
+        WHERE i.status = 'settled' AND (s.submission_id IS NULL OR s.request_id <> i.request_id OR s.outcome <> 'accepted')`,
+    },
+    {
+      code: "activeClock",
+      detail: "An active interval belongs to paused, terminal, or unconfigured work.",
+      sql: `SELECT DISTINCT a.run_id AS runId FROM attempt_active_intervals t
+        JOIN node_attempts a ON a.attempt_id = t.attempt_id JOIN runs r ON r.run_id = a.run_id
+        WHERE t.ended_at IS NULL AND (r.paused = 1 OR r.status NOT IN ('running', 'waiting')
+          OR a.status NOT IN ('pending', 'running', 'waiting') OR a.timeout_ms IS NULL)`,
+    },
+    {
+      code: "sessionTurns",
+      detail: "A Pi session has more than one open workflow turn.",
+      sql: `SELECT DISTINCT t.run_id AS runId FROM workflow_turns t WHERE t.state = 'started'
+        AND t.target_session_id IN (SELECT target_session_id FROM workflow_turns
+          WHERE state = 'started' GROUP BY target_session_id HAVING COUNT(*) > 1)`,
+    },
+  ];
+  return state.readTransaction(() =>
+    checks.flatMap(({ code, detail, sql }) =>
+      (state.connection.prepare(sql).all() as { runId: string }[]).map(({ runId }) => ({
+        code,
+        runId,
+        detail,
+      })),
+    ),
+  );
+}