@osolmaz/pi-workflows 0.13.1 → 0.13.2

package/src/extension/decision-channels.ts

@@ -28,6 +28,7 @@ const TELEGRAM_TEXT_LIMIT = 4_096;
 const PI_PRESENTATION_WINDOW_LINES = 18;
 const DEFAULT_API_BASE = "https://api.telegram.org";
 const LEASE_TTL_MS = 60_000;
+const LEASE_RENEW_WINDOW_MS = 20_000;
 const LEASE_RETRY_MS = 5_000;
 const POLL_BACKOFF_MS = 1_000;
 const MAX_SETTLEMENT_ATTEMPTS = 3;
@@ -428,6 +429,21 @@ class TelegramProjection {
   }
 
   acquire(now = Date.now()): boolean {
+    const observed = this.lease();
+    const observedToken = tokenHash(this.token);
+    const ownedByThis =
+      observed.ownerId === this.owner &&
+      observed.tokenHash !== null &&
+      observed.tokenHash.equals(observedToken) &&
+      observed.expiresAt !== null &&
+      observed.expiresAt > now;
+    if (ownedByThis) {
+      this.generation = observed.generation;
+      return true;
+    }
+    if (observed.ownerId !== null && observed.expiresAt !== null && observed.expiresAt > now) {
+      return false;
+    }
     return this.state.transaction(() => {
       const lease = this.lease();
       if (
@@ -438,7 +454,11 @@ class TelegramProjection {
       ) {
         return false;
       }
-      const generation = lease.ownerId === this.owner ? lease.generation : lease.generation + 1;
+      const sameToken =
+        lease.ownerId === this.owner &&
+        lease.tokenHash !== null &&
+        lease.tokenHash.equals(observedToken);
+      const generation = sameToken ? lease.generation : lease.generation + 1;
       const result = this.state.connection
         .prepare(
           `UPDATE leases
@@ -449,7 +469,7 @@ class TelegramProjection {
         .run(
           generation,
           this.owner,
-          tokenHash(this.token),
+          observedToken,
           now,
           now,
           now + LEASE_TTL_MS,
@@ -465,6 +485,18 @@ class TelegramProjection {
   }
 
   renew(now = Date.now()): boolean {
+    const lease = this.lease();
+    if (
+      lease.ownerId !== this.owner ||
+      lease.generation !== this.generation ||
+      lease.tokenHash === null ||
+      !lease.tokenHash.equals(tokenHash(this.token)) ||
+      lease.expiresAt === null ||
+      lease.expiresAt <= now
+    ) {
+      return false;
+    }
+    if (lease.expiresAt - now > LEASE_RENEW_WINDOW_MS) return true;
     return (
       this.state.connection
         .prepare(
@@ -1222,11 +1254,11 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
 
   private async poll(signal: AbortSignal): Promise<void> {
     while (this.running && !signal.aborted) {
-      if (!this.projection.acquire()) {
-        await wait(LEASE_RETRY_MS, signal);
-        continue;
-      }
       try {
+        if (!this.projection.acquire()) {
+          await wait(leaseRetryDelay(), signal);
+          continue;
+        }
         await this.deliverPendingRequests();
         const result = await this.call(
           "getUpdates",
@@ -1246,7 +1278,11 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
         if (!this.projection.renew()) this.projection.release();
       } catch {
         if (signal.aborted) return;
-        await wait(POLL_BACKOFF_MS, signal);
+        try {
+          await wait(POLL_BACKOFF_MS, signal);
+        } catch {
+          if (signal.aborted) return;
+        }
       }
     }
   }
@@ -1773,6 +1809,10 @@ async function writePrivateJson(filePath: string, value: unknown): Promise<void>
   await fsp.chmod(filePath, 0o600);
 }
 
+function leaseRetryDelay(): number {
+  return LEASE_RETRY_MS + Math.floor(Math.random() * 1_000);
+}
+
 async function wait(milliseconds: number, signal: AbortSignal): Promise<void> {
   await new Promise<void>((resolve) => {
     const timer = setTimeout(resolve, milliseconds);

package/src/extension/index.ts

@@ -9,6 +9,7 @@ import type {
 } from "../controllers/sqlite.js";
 import type { JsonObject } from "../controllers/types.js";
 import type { WorkflowSchedulerResult } from "../controllers/workflows.js";
+import { canonicalJson } from "../state/json.js";
 import { compositionMetadata } from "../workflows/composition.js";
 import { humanDecisionChannelRequest } from "../workflows/decision-presentation.js";
 import { WorkflowEngine } from "../workflows/engine.js";
@@ -219,7 +220,7 @@ type StartRunOptions = {
 };
 
 function definitionDigest(snapshot: WorkflowDefinitionSnapshot): string {
-  return `sha256:${createHash("sha256").update(JSON.stringify(snapshot)).digest("hex")}`;
+  return `sha256:${createHash("sha256").update(canonicalJson(snapshot)).digest("hex")}`;
 }
 
 function launchSourceIdentity(workflow: WorkflowDefinition, root: unknown): unknown {

package/src/extension/recorder.ts

@@ -246,6 +246,13 @@ export class SessionRecorder {
       return;
     }
     const normalized = normalizeAssistantEvent(event.assistantMessageEvent);
+    if (
+      normalized.type === "text_delta" ||
+      normalized.type === "thinking_delta" ||
+      normalized.type === "toolcall_delta"
+    ) {
+      return;
+    }
     const toolCallId = toolCallIdFromAssistantEvent(normalized);
     if (toolCallId) {
       this.toolOwners.set(toolCallId, owner);
@@ -295,14 +302,9 @@ export class SessionRecorder {
     });
   }
 
-  handleToolUpdate(event: ToolExecutionUpdateEventLike): void {
-    const owner = this.toolOwners.get(event.toolCallId);
-    if (!owner) {
-      return;
-    }
-    this.enqueue(owner, "tool_execution_updated", {}, undefined, {
-      toolCallId: event.toolCallId,
-    });
+  handleToolUpdate(_event: ToolExecutionUpdateEventLike): void {
+    // Incremental tool progress is transient. The recorder stores the settled
+    // tool result and the surrounding lifecycle facts.
   }
 
   handleToolEnd(event: ToolExecutionEndEventLike): void {

package/src/state/schema.ts

@@ -106,8 +106,15 @@ CREATE TABLE runs (
   paused INTEGER NOT NULL DEFAULT 0 CHECK (paused IN (0, 1)),
   status_detail TEXT,
   input_hash BLOB NOT NULL REFERENCES blobs(blob_hash),
-  output_hash BLOB REFERENCES blobs(blob_hash),
+  workflow_sources_hash BLOB REFERENCES blobs(blob_hash),
+  human_decision_hash BLOB REFERENCES blobs(blob_hash),
+  final_output_hash BLOB REFERENCES blobs(blob_hash),
   error_hash BLOB REFERENCES blobs(blob_hash),
+  carried_step_count INTEGER NOT NULL DEFAULT 0 CHECK (carried_step_count >= 0),
+  current_node TEXT,
+  current_attempt_id TEXT,
+  current_node_started_at INTEGER,
+  waiting_on TEXT,
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
   finished_at INTEGER,
@@ -159,9 +166,9 @@ CREATE TABLE node_attempts (
   )),
   input_hash BLOB REFERENCES blobs(blob_hash),
   contract_hash BLOB REFERENCES blobs(blob_hash),
-  presentation_hash BLOB REFERENCES blobs(blob_hash),
+  prompt_hash BLOB REFERENCES blobs(blob_hash),
   output_hash BLOB REFERENCES blobs(blob_hash),
-  result_hash BLOB REFERENCES blobs(blob_hash),
+  step_metadata_hash BLOB REFERENCES blobs(blob_hash),
   error_hash BLOB REFERENCES blobs(blob_hash),
   started_at INTEGER,
   deadline_at INTEGER,
@@ -175,10 +182,22 @@ 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 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;
+
+CREATE INDEX run_steps_attempt_idx ON run_steps(attempt_id);
+
 CREATE TABLE workflow_updates (
   update_id TEXT PRIMARY KEY,
   attempt_id TEXT NOT NULL REFERENCES node_attempts(attempt_id) ON DELETE CASCADE,
   update_seq INTEGER NOT NULL CHECK (update_seq > 0),
+  run_revision INTEGER NOT NULL CHECK (run_revision > 0),
   update_type TEXT NOT NULL,
   update_key TEXT NOT NULL,
   data_hash BLOB NOT NULL REFERENCES blobs(blob_hash),

package/src/viewer/session-reducer.ts

@@ -20,7 +20,6 @@ export type TemporalTool = {
   messageId: string;
   toolName: string;
   status: "running" | "finished" | "failed";
-  updates: number;
   args?: unknown;
   result?: unknown;
 };
@@ -155,22 +154,6 @@ function foldSessionEvents(
                 ? "thinking"
                 : "toolCall",
           );
-        } else if (
-          contentIndex !== undefined &&
-          (assistantType === "text_delta" ||
-            assistantType === "thinking_delta" ||
-            assistantType === "toolcall_delta")
-        ) {
-          const block = ensureBlock(
-            message,
-            contentIndex,
-            assistantType === "text_delta"
-              ? "text"
-              : assistantType === "thinking_delta"
-                ? "thinking"
-                : "toolCall",
-          );
-          block.text += payloadString(event.payload, "delta") ?? "";
         } else if (
           contentIndex !== undefined &&
           (assistantType === "text_end" || assistantType === "thinking_end")
@@ -181,10 +164,10 @@ function foldSessionEvents(
             assistantType === "text_end" ? "text" : "thinking",
           );
           const content = payloadString(event.payload, "content") ?? "";
-          if (block.text !== content) {
+          if (block.text.length > 0 && block.text !== content) {
             diagnostics.push(`${assistantType} mismatch for ${event.messageId}:${contentIndex}`);
-            block.text = content;
           }
+          block.text = content;
         } else if (contentIndex !== undefined && assistantType === "toolcall_end") {
           const block = ensureBlock(message, contentIndex, "toolCall");
           block.value = event.payload.toolCall;
@@ -229,22 +212,12 @@ function foldSessionEvents(
           messageId: event.messageId,
           toolName: payloadString(event.payload, "toolName") ?? "tool",
           status: "running",
-          updates: 0,
           ...(event.payload.args === undefined ? {} : { args: event.payload.args }),
         };
         tools.set(event.toolCallId, tool);
         toolOrder.push(event.toolCallId);
         break;
       }
-      case "tool_execution_updated": {
-        const tool = event.toolCallId ? tools.get(event.toolCallId) : undefined;
-        if (tool) {
-          tool.updates += 1;
-        } else {
-          diagnostics.push(`tool_execution_updated ${event.seq} precedes start`);
-        }
-        break;
-      }
       case "tool_execution_finished": {
         const tool = event.toolCallId ? tools.get(event.toolCallId) : undefined;
         if (!tool) {

package/src/workflows/engine.ts

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { canonicalJson } from "../state/json.js";
 import {
   compileWorkflowDefinition,
   compositionMetadata,
@@ -723,8 +724,8 @@ export class WorkflowEngine {
         throw new RunParkedError();
       }
       this.recordAttempt(workflow, state, attempt);
-      // The terminal node event carries the output, receipt, and conversation
-      // linkage so the trace alone is sufficient to reconstruct the run.
+      // The durable step row owns the output. The trace keeps the terminal fact
+      // and compact execution metadata without copying the output value.
       await this.persist(runId, state, {
         scope: "node",
         type: attempt.result.outcome === "ok" ? "node_finished" : "node_failed",
@@ -1561,7 +1562,7 @@ function workflowIdentityMismatch(
 
 function definitionDigest(workflow: WorkflowDefinition): string {
   return `sha256:${createHash("sha256")
-    .update(JSON.stringify(createDefinitionSnapshot(workflow)))
+    .update(canonicalJson(createDefinitionSnapshot(workflow)))
     .digest("hex")}`;
 }