@osolmaz/pi-workflows 0.13.0 → 0.13.2

package/src/controllers/sqlite.ts

@@ -156,9 +156,9 @@ type RunRow = {
   workflowRef: string;
   runStatus: string;
   workflowSourceHash: Buffer;
+  workflowSourcesHash: Buffer | null;
   definitionDigest: Buffer;
   inputHash: Buffer;
-  outputHash: Buffer | null;
   launchOptionsHash: Buffer;
   status: WorkflowRunLaunchStatus;
   availableAt: number;
@@ -1049,34 +1049,11 @@ export class SqliteControllerStore implements ControllerStore {
       const resourceId = resourceIdFor("run", options.runId);
       const definitionHash = this.state.putJson(options.definitionSnapshot, now);
       const queuedSource = queuedWorkflowSource(options.workflowSource);
-      const sourceHash = this.state.putJson(options.workflowSource, now);
+      const sourceHash = this.state.putJson(queuedSource.root, now);
+      const mountedSourcesHash =
+        queuedSource.mounted.length === 0 ? null : this.state.putJson(queuedSource.mounted, now);
       const inputHash = this.state.putJson(options.input ?? null, now);
       const launchHash = this.state.putJson(options.launchOptions ?? {}, now);
-      const queuedStateHash = this.state.putJson(
-        {
-          schema: "pi-workflows.run-state.v1",
-          traceSeq: 1,
-          runId: options.runId,
-          workflowName: options.workflowName,
-          workflowSource: queuedSource.root,
-          ...(queuedSource.mounted.length === 0
-            ? {}
-            : {
-                workflowSources: queuedSource.mounted,
-                definitionDigest: options.definitionDigest,
-              }),
-          ...(options.parentRunId === undefined ? {} : { parentRunId: options.parentRunId }),
-          startedAt: new Date(now).toISOString(),
-          updatedAt: new Date(now).toISOString(),
-          status: "running",
-          input: options.input ?? null,
-          outputs: {},
-          results: {},
-          steps: [],
-          updates: [],
-        },
-        now,
-      );
       this.state.connection
         .prepare(
           `INSERT INTO workflow_definitions(
@@ -1101,7 +1078,7 @@ export class SqliteControllerStore implements ControllerStore {
              run_id, resource_id, project_id, parent_run_id, definition_digest,
              workflow_ref, workflow_source_hash, launch_options_hash,
              source_type, source_ref, source_revision, status, paused,
-             input_hash, output_hash, created_at, updated_at
+             input_hash, workflow_sources_hash, created_at, updated_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', 0, ?, ?, ?, ?)`,
         )
         .run(
@@ -1117,7 +1094,7 @@ export class SqliteControllerStore implements ControllerStore {
           source.ref,
           source.revision,
           inputHash,
-          queuedStateHash,
+          mountedSourcesHash,
           now,
           now,
         );
@@ -2261,7 +2238,11 @@ export class SqliteControllerStore implements ControllerStore {
       runId: row.runId,
       workflowName: row.workflowName,
       workflowSourceRef: row.workflowRef,
-      workflowSource: this.state.readJson(row.workflowSourceHash),
+      workflowSource: {
+        root: this.state.readJson(row.workflowSourceHash),
+        mounted:
+          row.workflowSourcesHash === null ? [] : this.state.readJson(row.workflowSourcesHash),
+      },
       initialized: row.runStatus !== "queued",
       definitionDigest: `sha256:${row.definitionDigest.toString("hex")}`,
       input: this.state.readJson(row.inputHash),
@@ -2461,27 +2442,8 @@ export class SqliteControllerStore implements ControllerStore {
       ) {
         return false;
       }
-      if (row.outputHash === null) throw new Error(`Workflow run ${runId} has no state projection`);
-      const projected = this.state.readJson(row.outputHash);
-      if (!isRecord(projected)) throw new Error(`Workflow run ${runId} state is invalid`);
       const revision = this.resourceRevision(row.resourceId);
-      const at = new Date(now).toISOString();
-      const terminalState: Record<string, unknown> = {
-        ...projected,
-        traceSeq: revision + 1,
-        status,
-        updatedAt: at,
-        finishedAt: at,
-        error,
-      };
-      delete terminalState.currentNode;
-      delete terminalState.currentAttemptId;
-      delete terminalState.currentNodeStartedAt;
-      delete terminalState.statusDetail;
-      delete terminalState.paused;
-      delete terminalState.waitingOn;
       const errorHash = this.state.putText(error, now);
-      const outputHash = this.state.putJson(terminalState, now);
       const queueUpdate = this.state.connection
         .prepare(
           `UPDATE run_queue
@@ -2506,10 +2468,13 @@ export class SqliteControllerStore implements ControllerStore {
       this.state.connection
         .prepare(
           `UPDATE runs
-           SET status = ?, output_hash = ?, error_hash = ?, updated_at = ?, finished_at = ?
+           SET status = ?, paused = 0, status_detail = NULL, error_hash = ?,
+               current_node = NULL, current_attempt_id = NULL,
+               current_node_started_at = NULL, waiting_on = NULL,
+               updated_at = ?, finished_at = ?
            WHERE run_id = ?`,
         )
-        .run(status, outputHash, errorHash, now, now, runId);
+        .run(status, errorHash, now, now, runId);
       this.bumpResource(row.resourceId, revision, now);
       this.insertEvent(
         row.resourceId,
@@ -2811,8 +2776,9 @@ function workflowSelect(clause: string): string {
 function workflowRunSelect(clause: string): string {
   return `SELECT r.run_id AS runId, r.resource_id AS resourceId,
     d.workflow_name AS workflowName, r.workflow_ref AS workflowRef, r.status AS runStatus,
-    r.workflow_source_hash AS workflowSourceHash, r.definition_digest AS definitionDigest,
-    r.input_hash AS inputHash, r.output_hash AS outputHash,
+    r.workflow_source_hash AS workflowSourceHash,
+    r.workflow_sources_hash AS workflowSourcesHash,
+    r.definition_digest AS definitionDigest, r.input_hash AS inputHash,
     r.launch_options_hash AS launchOptionsHash,
     q.status, q.available_at AS availableAt, q.affinity_runner_id AS affinityRunnerId,
     q.consecutive_errors AS consecutiveErrors, q.error_code AS errorCode,

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/executor.ts

@@ -253,10 +253,7 @@ export class ConversationStepExecutor implements AgentStepExecutor {
     });
     return {
       accepted: true,
-      message: [
-        `Output accepted for step ${JSON.stringify(stepId)}.`,
-        "If the workflow continues, the next step arrives as a new workflow message. End your turn now.",
-      ].join(" "),
+      message: `Output accepted for step ${JSON.stringify(stepId)}.`,
     };
   }
 

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 {
@@ -560,7 +561,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
   };
   let activeRun: ActiveRun | null = null;
   let systemTurnAbort: { contract: AgentStepContract; intentId?: string } | null = null;
-  let suppressWorkflowAssistantTail = false;
   let lastExpiredAttempt: { contract: AgentStepContract; reason: string } | null = null;
   // The interactive run currently parked at a checkpoint, if any.
   let lastWaitingRunId: string | null = null;
@@ -999,7 +999,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
           resolution: "presentation",
           send: (turnIntentId) => {
             presentationPending = run.generation;
-            suppressWorkflowAssistantTail = false;
             pi.sendMessage(
               {
                 customType: PRESENTATION_MESSAGE_TYPE,
@@ -2916,7 +2915,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
           if (!result.accepted) {
             throw new Error(result.message);
           }
-          suppressWorkflowAssistantTail = true;
           return {
             content: [{ type: "text", text: result.message }],
             details: { action: "submit", step: params.step, accepted: true },
@@ -2994,7 +2992,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
   });
 
   pi.on("agent_start", () => {
-    suppressWorkflowAssistantTail = false;
     if (!activeRun && presentationPending === null && presentationAbort) {
       // A normal user turn started while an async presentation prompt was
       // still resolving. The user's new request supersedes that old result.
@@ -3005,7 +3002,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
   });
 
   pi.on("agent_end", (event, ctx) => {
-    suppressWorkflowAssistantTail = false;
     const aborted = event.messages.some(
       (message) =>
         typeof message === "object" &&
@@ -3057,14 +3053,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
   });
 
   pi.on("message_end", (event) => {
-    if (suppressWorkflowAssistantTail && event.message.role === "assistant") {
-      const message = {
-        ...event.message,
-        content: event.message.content.filter((part) => part.type !== "text"),
-      };
-      activeRun?.recorder?.handleMessageEnd({ ...event, message });
-      return { message };
-    }
     activeRun?.recorder?.handleMessageEnd(event);
   });
 
@@ -3127,7 +3115,6 @@ export default function piWorkflows(pi: ExtensionAPI) {
     sessionClosed = true;
     herdrProbeGeneration += 1;
     systemTurnAbort = null;
-    suppressWorkflowAssistantTail = false;
     turnCoordinator.clearDeferred();
     supersedePresentation();
     const run = activeRun;

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")}`;
 }