@workglow/task-graph 0.2.37 → 0.3.1

package/dist/bun.js

@@ -1278,14 +1278,14 @@ import { EventEmitter as EventEmitter4, uuid4 as uuid45 } from "@workglow/util";
 import { DirectedAcyclicGraph } from "@workglow/util/graph";
 
 // src/task/GraphAsTask.ts
-import { getLogger as getLogger6 } from "@workglow/util";
+import { getLogger as getLogger7 } from "@workglow/util";
 import { CycleError } from "@workglow/util/graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
-  getLogger as getLogger5,
+  getLogger as getLogger6,
   getTelemetryProvider as getTelemetryProvider2,
   globalServiceRegistry as globalServiceRegistry3,
   ResourceScope as ResourceScope2,
@@ -1294,9 +1294,39 @@ import {
   uuid4 as uuid44
 } from "@workglow/util";
 
+// src/cache/CacheJanitor.ts
+class CacheJanitor {
+  privateBacking;
+  constructor({ privateBacking }) {
+    this.privateBacking = privateBacking;
+  }
+  async sweepStaleRunPrivate(olderThanMs) {
+    await this.privateBacking.clearOlderThanWithTaskTypePrefix("__run:", olderThanMs);
+  }
+}
+// src/cache/CachePolicy.ts
+var DEFAULT_CACHE_POLICY = { kind: "deterministic" };
+function isPolicyCached(policy) {
+  return policy.kind !== "none";
+}
+function isPolicyPrivate(policy) {
+  return policy.kind === "private";
+}
+// src/cache/CacheRegistry.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var CACHE_REGISTRY = createServiceToken2("taskgraph.cacheRegistry");
+
+class DefaultCacheRegistry {
+  deterministic;
+  private;
+  constructor(init = {}) {
+    this.deterministic = init.deterministic;
+    this.private = init.private;
+  }
+}
 // src/storage/TaskOutputRepository.ts
-import { createServiceToken as createServiceToken2, EventEmitter as EventEmitter2 } from "@workglow/util";
-var TASK_OUTPUT_REPOSITORY = createServiceToken2("taskgraph.taskOutputRepository");
+import { createServiceToken as createServiceToken3, EventEmitter as EventEmitter2 } from "@workglow/util";
+var TASK_OUTPUT_REPOSITORY = createServiceToken3("taskgraph.taskOutputRepository");
 
 class TaskOutputRepository {
   outputCompression;
@@ -1322,10 +1352,53 @@ class TaskOutputRepository {
   emit(name, ...args) {
     this._events?.emit(name, ...args);
   }
+  async deleteByTaskTypePrefix(_prefix) {
+    throw new Error(`${this.constructor.name}: deleteByTaskTypePrefix is not supported by this repository.`);
+  }
+  async clearOlderThanWithTaskTypePrefix(_prefix, _olderThanMs) {
+    throw new Error(`${this.constructor.name}: clearOlderThanWithTaskTypePrefix is not supported by this repository.`);
+  }
+  async sizeByTaskTypePrefix(_prefix) {
+    throw new Error(`${this.constructor.name}: sizeByTaskTypePrefix is not supported by this repository.`);
+  }
 }
 
+// src/cache/RunPrivateCacheRepo.ts
+class RunPrivateCacheRepo extends TaskOutputRepository {
+  backing;
+  runId;
+  constructor({ backing, runId }) {
+    super({ outputCompression: backing.outputCompression });
+    this.backing = backing;
+    this.runId = runId;
+  }
+  ns(taskType) {
+    return `__run:${this.runId}::${taskType}`;
+  }
+  async saveOutput(taskType, inputs, output, createdAt) {
+    await this.backing.saveOutput(this.ns(taskType), inputs, output, createdAt);
+  }
+  async getOutput(taskType, inputs) {
+    return this.backing.getOutput(this.ns(taskType), inputs);
+  }
+  async clear() {
+    await this.clearRun();
+  }
+  async clearRun() {
+    await this.backing.deleteByTaskTypePrefix(`__run:${this.runId}::`);
+  }
+  async size() {
+    return this.backing.sizeByTaskTypePrefix(`__run:${this.runId}::`);
+  }
+  async clearOlderThan(olderThanInMs) {
+    await this.backing.clearOlderThanWithTaskTypePrefix(`__run:${this.runId}::`, olderThanInMs);
+  }
+  isDurable() {
+    return this.backing.isDurable();
+  }
+}
 // src/task/EntitlementEnforcer.ts
-import { createServiceToken as createServiceToken4 } from "@workglow/util";
+import { createServiceToken as createServiceToken5 } from "@workglow/util";
 
 // src/task/EntitlementPolicy.ts
 var EMPTY_POLICY = Object.freeze({
@@ -1369,7 +1442,7 @@ function can(policy, id, resources) {
 }
 
 // src/task/EntitlementResolver.ts
-import { createServiceToken as createServiceToken3 } from "@workglow/util";
+import { createServiceToken as createServiceToken4 } from "@workglow/util";
 var PERMISSIVE_RESOLVER = {
   lookup: () => "grant",
   prompt: async () => "grant",
@@ -1380,7 +1453,7 @@ var DENY_ALL_RESOLVER = {
   prompt: async () => "deny",
   save: () => {}
 };
-var ENTITLEMENT_RESOLVER = createServiceToken3("workglow.entitlementResolver");
+var ENTITLEMENT_RESOLVER = createServiceToken4("workglow.entitlementResolver");
 
 // src/task/EntitlementEnforcer.ts
 function formatEntitlementDenial(denial) {
@@ -1453,7 +1526,7 @@ function createScopedEnforcer(grants) {
 function createGrantListEnforcer(grants) {
   return createScopedEnforcer(grants.map((id) => ({ id })));
 }
-var ENTITLEMENT_ENFORCER = createServiceToken4("workglow.entitlementEnforcer");
+var ENTITLEMENT_ENFORCER = createServiceToken5("workglow.entitlementEnforcer");
 
 // src/task/StreamTypes.ts
 function getPortStreamMode(schema, portId) {
@@ -1556,246 +1629,13 @@ function hasStructuredOutput(schema) {
   return getStructuredOutputSchemas(schema).size > 0;
 }
 
-// src/task-graph/EdgeMaterializer.ts
-import { getLogger } from "@workglow/util";
-import { previewSource } from "@workglow/util/media";
-class EdgeMaterializer {
-  graph;
-  runner;
-  constructor(graph, runner) {
-    this.graph = graph;
-    this.runner = runner;
-  }
-  filterInputForTask(task, input) {
-    const sourceDataflows = this.graph.getSourceDataflows(task.id);
-    const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
-    const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
-    const filteredInput = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (!connectedInputs.has(key) && !allPortsConnected) {
-        filteredInput[key] = value;
-      }
-    }
-    return filteredInput;
-  }
-  copyInputFromEdgesToNode(task) {
-    const dataflows = this.graph.getSourceDataflows(task.id);
-    dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    for (const dataflow of dataflows) {
-      const live = dataflow.getCurrentValue();
-      const port = dataflow.targetTaskPortId;
-      let portData;
-      if (port === DATAFLOW_ALL_PORTS) {
-        portData = live;
-      } else if (port === DATAFLOW_ERROR_PORT) {
-        portData = { [DATAFLOW_ERROR_PORT]: dataflow.error };
-      } else {
-        portData = { [port]: live };
-      }
-      this.runner.addInputData(task, portData);
-    }
-  }
-  async pushOutputFromNodeToEdges(node, results) {
-    const dataflows = this.graph.getTargetDataflows(node.id);
-    if (this.runner["previewRunning"] && Object.keys(results).length > 0) {
-      for (const port of Object.keys(results)) {
-        const value = results[port];
-        if (EdgeMaterializer.isImageValueShape(value)) {
-          results[port] = await previewSource(value);
-        }
-      }
-    }
-    for (const dataflow of dataflows) {
-      if (dataflow.stream !== undefined)
-        continue;
-      const registry = this.runner["registry"];
-      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow, registry);
-      if (compatibility === "static") {
-        dataflow.setPortData(results);
-        await dataflow.applyTransforms(registry);
-      } else if (compatibility === "runtime") {
-        const task = this.graph.getTask(dataflow.targetTaskId);
-        const narrowed = await task.narrowInput({ ...results }, registry);
-        dataflow.setPortData(narrowed);
-        await dataflow.applyTransforms(registry);
-      } else {
-        const resultsKeys = Object.keys(results);
-        if (resultsKeys.length > 0) {
-          getLogger().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
-            dataflowId: dataflow.id,
-            compatibility,
-            resultsKeys
-          });
-        }
-      }
-    }
-  }
-  pushErrorFromNodeToEdges(node) {
-    if (!node?.config?.id)
-      return;
-    this.graph.getTargetDataflows(node.id).forEach((dataflow) => {
-      dataflow.error = node.error;
-    });
-  }
-  hasErrorOutputEdges(task) {
-    const dataflows = this.graph.getTargetDataflows(task.id);
-    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
-  }
-  pushErrorOutputToEdges(task) {
-    const taskError = task.error;
-    const errorData = {
-      error: taskError?.message ?? "Unknown error",
-      errorType: taskError?.constructor?.type ?? "TaskError"
-    };
-    const dataflows = this.graph.getTargetDataflows(task.id);
-    for (const df of dataflows) {
-      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
-        df.value = errorData;
-        df.setStatus(TaskStatus.COMPLETED);
-      } else {
-        df.setStatus(TaskStatus.DISABLED);
-      }
-    }
-    this.runner["runScheduler"].propagateDisabledStatus(this.runner["currentCtx"]);
-  }
-  resetTask(graph, task, runId) {
-    task.status = TaskStatus.PENDING;
-    task.resetInputData();
-    task.runOutputData = {};
-    task.error = undefined;
-    task.progress = 0;
-    task.runConfig = { ...task.runConfig, runnerId: runId };
-    this.runner["runScheduler"].pushStatusFromNodeToEdges(task, this.runner["currentCtx"], undefined, graph);
-    if (task?.config?.id) {
-      graph.getTargetDataflows(task.id).forEach((dataflow) => {
-        dataflow.error = task.error;
-      });
-    }
-    task.emit("reset");
-    task.emit("status", task.status);
-  }
-  static isImageValueShape(v) {
-    if (v === null || typeof v !== "object")
-      return false;
-    const o = v;
-    return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
-  }
-}
-
-// src/task-graph/RunContext.ts
-import { uuid4 as uuid42 } from "@workglow/util";
-
-class RunContext {
-  runId;
-  abortController;
-  inProgressTasks = new Map;
-  inProgressFunctions = new Map;
-  failedTaskErrors = new Map;
-  telemetrySpan;
-  graphTimeoutTimer;
-  pendingGraphTimeoutError;
-  activeEnforcer;
-  parentSignalCleanup;
-  constructor(parentSignal) {
-    this.runId = uuid42();
-    this.abortController = new AbortController;
-    if (parentSignal) {
-      const onParentAbort = () => this.abortController.abort();
-      parentSignal.addEventListener("abort", onParentAbort, { once: true });
-      this.parentSignalCleanup = () => parentSignal.removeEventListener("abort", onParentAbort);
-      if (parentSignal.aborted) {
-        this.parentSignalCleanup();
-        this.parentSignalCleanup = undefined;
-        this.abortController.abort();
-      }
-    }
-  }
-  dispose() {
-    this.parentSignalCleanup?.();
-    this.parentSignalCleanup = undefined;
-  }
-}
-
-// src/task-graph/RunScheduler.ts
-import { getLogger as getLogger4 } from "@workglow/util";
-
-// src/task/ConditionalTask.ts
-import { getLogger as getLogger3 } from "@workglow/util";
-
-// src/task/ConditionUtils.ts
-function evaluateCondition(fieldValue, operator, compareValue) {
-  if (fieldValue === null || fieldValue === undefined) {
-    switch (operator) {
-      case "is_empty":
-        return true;
-      case "is_not_empty":
-        return false;
-      case "is_true":
-        return false;
-      case "is_false":
-        return true;
-      default:
-        return false;
-    }
-  }
-  const strValue = String(fieldValue);
-  const numValue = Number(fieldValue);
-  switch (operator) {
-    case "equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue === Number(compareValue);
-      }
-      return strValue === compareValue;
-    case "not_equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue !== Number(compareValue);
-      }
-      return strValue !== compareValue;
-    case "greater_than":
-      return numValue > Number(compareValue);
-    case "greater_or_equal":
-      return numValue >= Number(compareValue);
-    case "less_than":
-      return numValue < Number(compareValue);
-    case "less_or_equal":
-      return numValue <= Number(compareValue);
-    case "contains":
-      return strValue.toLowerCase().includes(compareValue.toLowerCase());
-    case "starts_with":
-      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
-    case "ends_with":
-      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
-    case "is_empty":
-      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
-    case "is_not_empty":
-      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
-    case "is_true":
-      return Boolean(fieldValue) === true;
-    case "is_false":
-      return Boolean(fieldValue) === false;
-    default:
-      return false;
-  }
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
-    }
-    current = current[part];
-  }
-  return current;
-}
-
 // src/task/Task.ts
-import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid43 } from "@workglow/util";
+import { deepEqual, EventEmitter as EventEmitter3, getLogger as getLogger2, uuid4 as uuid42 } from "@workglow/util";
 import { compileSchema } from "@workglow/util/schema";
 
 // src/task/TaskRunner.ts
 import {
-  getLogger as getLogger2,
+  getLogger,
   getTelemetryProvider,
   globalServiceRegistry as globalServiceRegistry2,
   ResourceScope,
@@ -1804,7 +1644,6 @@ import {
 
 // src/task/CacheCoordinator.ts
 import { getPortCodec } from "@workglow/util";
-
 class CacheCoordinator {
   task;
   constructor(task) {
@@ -1814,7 +1653,9 @@ class CacheCoordinator {
     if (!outputCache)
       return inputs;
     const inputSchema = this.task.constructor.inputSchema();
-    return await CacheCoordinator.normalizeInputsForCacheKey(inputs, inputSchema);
+    const normalized = await CacheCoordinator.normalizeInputsForCacheKey(inputs, inputSchema);
+    normalized.__cv = this.task.getCacheVersion();
+    return normalized;
   }
   async lookup(keyInputs, outputCache, isStreamable, ctx) {
     if (!outputCache || !this.task.cacheable)
@@ -1842,6 +1683,20 @@ class CacheCoordinator {
     const wireOutputs = await CacheCoordinator.serializeOutputPorts(output, outputSchema);
     await outputCache.saveOutput(this.task.type, keyInputs, wireOutputs);
   }
+  repoFor(registry, policy) {
+    if (!registry || !isPolicyCached(policy))
+      return;
+    return isPolicyPrivate(policy) ? registry.private : registry.deterministic;
+  }
+  async buildKeyForPolicy(inputs, registry, policy) {
+    return this.buildKey(inputs, this.repoFor(registry, policy));
+  }
+  async lookupByPolicy(keyInputs, registry, policy, isStreamable, ctx) {
+    return this.lookup(keyInputs, this.repoFor(registry, policy), isStreamable, ctx);
+  }
+  async saveByPolicy(keyInputs, output, registry, policy) {
+    return this.save(keyInputs, output, this.repoFor(registry, policy));
+  }
   static async serializeOutputPorts(output, schema) {
     if (!schema?.properties)
       return output;
@@ -2077,12 +1932,15 @@ class TaskRunner {
   task;
   currentCtx;
   outputCache;
+  cacheRegistry;
   cacheCoordinator;
   streamProcessor;
   registry = globalServiceRegistry2;
   resourceScope;
   ownsResourceScope = false;
   inputStreams;
+  runId;
+  static __privateWithoutRunIdWarned = new Set;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
@@ -2120,11 +1978,23 @@ class TaskRunner {
         if (!isStreamable && typeof this.task.executeStream !== "function") {
           const streamMode = getOutputStreamMode(this.task.outputSchema());
           if (streamMode !== "none") {
-            getLogger2().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
+            getLogger().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
+          }
+        }
+        let policy = this.task.getCachePolicy(inputs);
+        if (policy.kind === "private" && !this.runId && this.cacheRegistry?.private !== undefined && !(this.cacheRegistry.private instanceof RunPrivateCacheRepo)) {
+          const taskType = this.task.type;
+          if (!TaskRunner.__privateWithoutRunIdWarned.has(taskType)) {
+            TaskRunner.__privateWithoutRunIdWarned.add(taskType);
+            getLogger().warn(`TaskRunner: task "${taskType}" has a private cache policy but no runId was ` + `provided. Private cache writes are skipped for this run \u2014 use TaskGraphRunner ` + `with runId for run-namespaced private caching, or provide an already namespaced ` + `private cache repo in CACHE_REGISTRY.`);
           }
+          policy = { kind: "none" };
         }
-        const keyInputs = await this.cacheCoordinator.buildKey(inputs, this.outputCache);
-        let outputs = await this.cacheCoordinator.lookup(keyInputs, this.outputCache, isStreamable, ctx);
+        this.currentCtx?.telemetrySpan?.setAttributes({
+          "workglow.task.cache_policy": policy.kind
+        });
+        const keyInputs = await this.cacheCoordinator.buildKeyForPolicy(inputs, this.cacheRegistry, policy);
+        let outputs = await this.cacheCoordinator.lookupByPolicy(keyInputs, this.cacheRegistry, policy, isStreamable, ctx);
         if (outputs === undefined) {
           outputs = isStreamable ? await this.streamProcessor.run(inputs, ctx, {
             registry: this.registry,
@@ -2133,7 +2003,7 @@ class TaskRunner {
             onProgress: this.handleProgress.bind(this),
             own: this.own
           }) : await this.executeTask(inputs, ctx);
-          await this.cacheCoordinator.save(keyInputs, outputs, this.outputCache);
+          await this.cacheCoordinator.saveByPolicy(keyInputs, outputs, this.cacheRegistry, policy);
           this.task.runOutputData = outputs ?? {};
         }
         await this.handleComplete();
@@ -2170,7 +2040,7 @@ class TaskRunner {
       }
       await this.handleCompletePreview();
     } catch (err) {
-      getLogger2().debug("runPreview failed", { taskId: this.task.config?.id, error: err });
+      getLogger().debug("runPreview failed", { taskId: this.task.config?.id, error: err });
       await this.handleErrorPreview();
     } finally {
       ctx.dispose();
@@ -2255,7 +2125,7 @@ class TaskRunner {
             const out = await this.runPreview(overrides);
             yield out;
           } catch (err) {
-            getLogger2().debug("runPreviewStream iteration failed", {
+            getLogger().debug("runPreviewStream iteration failed", {
               taskId: this.task.config?.id,
               error: err
             });
@@ -2298,7 +2168,8 @@ class TaskRunner {
       updateProgress: this.handleProgress.bind(this),
       own: this.own,
       registry: this.registry,
-      resourceScope: this.resourceScope
+      resourceScope: this.resourceScope,
+      runId: this.runId
     });
     return result;
   }
@@ -2326,22 +2197,29 @@ class TaskRunner {
     ctx.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
-    const cache = config.outputCache ?? this.task.runConfig?.outputCache;
-    if (cache === true) {
-      let instance = globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY);
+    if (config.registry) {
+      this.registry = config.registry;
+    }
+    this.runId = config.runId;
+    const legacy = config.outputCache ?? this.task.runConfig?.outputCache;
+    if (legacy === false) {
+      this.cacheRegistry = undefined;
+      this.outputCache = undefined;
+    } else if (legacy instanceof TaskOutputRepository) {
+      this.cacheRegistry = new DefaultCacheRegistry({ deterministic: legacy });
+      this.outputCache = legacy;
+    } else if (legacy === true) {
+      const instance = globalServiceRegistry2.has(TASK_OUTPUT_REPOSITORY) ? globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY) : undefined;
       this.outputCache = instance;
-    } else if (cache === false) {
+      this.cacheRegistry = instance ? new DefaultCacheRegistry({ deterministic: instance }) : undefined;
+    } else {
       this.outputCache = undefined;
-    } else if (cache instanceof TaskOutputRepository) {
-      this.outputCache = cache;
+      this.cacheRegistry = this.registry.has(CACHE_REGISTRY) ? this.registry.get(CACHE_REGISTRY) : undefined;
     }
     ctx.shouldAccumulate = config.shouldAccumulate !== false;
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
-    if (config.registry) {
-      this.registry = config.registry;
-    }
     if (config.resourceScope) {
       this.resourceScope = config.resourceScope;
     }
@@ -2363,7 +2241,6 @@ class TaskRunner {
         attributes: {
           "workglow.task.type": this.task.type,
           "workglow.task.id": String(this.task.config.id),
-          "workglow.task.cacheable": this.task.cacheable,
           "workglow.task.title": this.task.title || undefined
         }
       });
@@ -2494,12 +2371,15 @@ class Task {
   static title = "";
   static description = "";
   static cacheable = true;
+  static version = 1;
+  static cachePolicy = { kind: "deterministic" };
   static hasDynamicSchemas = false;
   static passthroughInputsToOutputs = false;
   static customizable = false;
   static isGraphOutput = false;
   static isPassthrough = false;
   static hasDynamicEntitlements = false;
+  static __cacheableDeprecationWarned = new Set;
   static entitlements() {
     return EMPTY_ENTITLEMENTS;
   }
@@ -2578,7 +2458,39 @@ class Task {
     return this.config?.description ?? this.constructor.description;
   }
   get cacheable() {
-    return this.runConfig?.cacheable ?? this.config?.cacheable ?? this.constructor.cacheable;
+    if (this.runConfig?.cacheable !== undefined)
+      return this.runConfig.cacheable;
+    if (this.config?.cacheable !== undefined)
+      return this.config.cacheable;
+    return this.getCachePolicy(this.runInputData ?? {}).kind !== "none";
+  }
+  getCacheVersion() {
+    const versions = [];
+    let ctor = this.constructor;
+    while (ctor && ctor !== Function.prototype) {
+      if (Object.prototype.hasOwnProperty.call(ctor, "version") && typeof ctor.version === "number") {
+        versions.push(ctor.version);
+      }
+      ctor = Object.getPrototypeOf(ctor);
+    }
+    if (versions.length === 0)
+      versions.push(1);
+    return versions.join(".");
+  }
+  getCachePolicy(_inputs) {
+    const ctor = this.constructor;
+    const hasLegacyOverride = Object.prototype.hasOwnProperty.call(ctor, "cacheable") && ctor.cacheable === false;
+    const hasPolicyOverride = Object.prototype.hasOwnProperty.call(ctor, "cachePolicy");
+    if (hasLegacyOverride && !hasPolicyOverride) {
+      if (!Task.__cacheableDeprecationWarned.has(ctor.type)) {
+        Task.__cacheableDeprecationWarned.add(ctor.type);
+        getLogger2().warn(`Task "${ctor.type}": static \`cacheable = false\` is deprecated. ` + `Use \`static cachePolicy: CachePolicy = { kind: "none" }\` instead.`);
+      }
+      return { kind: "none" };
+    }
+    if (this.runConfig?.cacheable === false || this.config?.cacheable === false)
+      return { kind: "none" };
+    return ctor.cachePolicy ?? DEFAULT_CACHE_POLICY;
   }
   defaults;
   runInputData = {};
@@ -2613,7 +2525,7 @@ class Task {
       ...title ? { title } : {}
     }, restConfig);
     if (baseConfig.id === undefined) {
-      baseConfig.id = uuid43();
+      baseConfig.id = uuid42();
     }
     this.config = this.validateAndApplyConfigDefaults(baseConfig);
     try {
@@ -2622,6 +2534,10 @@ class Task {
       this.originalConfig = undefined;
     }
     this.runConfig = runConfig;
+    const inputSchema = this.constructor.inputSchema();
+    if (inputSchema && typeof inputSchema !== "boolean" && inputSchema.properties && Object.prototype.hasOwnProperty.call(inputSchema.properties, "__cv")) {
+      throw new TaskConfigurationError(`Task "${this.constructor.type}": input port name '__cv' is reserved ` + `for cache versioning. Rename the port to avoid collision with the cache key sentinel.`);
+    }
   }
   getDefaultInputsFromStaticInputDefinitions() {
     const schema = this.inputSchema();
@@ -2919,91 +2835,320 @@ class Task {
           result[key] = this.stripSymbols(obj[key]);
         }
       }
-      return result;
+      return result;
+    }
+    return obj;
+  }
+  canSerializeConfig() {
+    return true;
+  }
+  toJSON(_options) {
+    const ctor = this.constructor;
+    if (!this.canSerializeConfig() || !this.originalConfig) {
+      throw new TaskSerializationError(this.type);
+    }
+    const schema = ctor.configSchema();
+    const schemaProperties = typeof schema !== "boolean" && schema?.properties ? schema.properties : {};
+    const config = {};
+    for (const [key, propSchema] of Object.entries(schemaProperties)) {
+      if (key === "id")
+        continue;
+      if (propSchema?.["x-ui-hidden"] === true && key !== "inputSchema" && key !== "outputSchema" && key !== "extras") {
+        continue;
+      }
+      const value = this.originalConfig[key];
+      if (value === undefined)
+        continue;
+      if (typeof value === "function" || typeof value === "symbol")
+        continue;
+      config[key] = value;
+    }
+    if (config.title === ctor.title)
+      delete config.title;
+    if (config.description === ctor.description)
+      delete config.description;
+    const extras = config.extras;
+    if (!extras || Object.keys(extras).length === 0)
+      delete config.extras;
+    const base = {
+      id: this.id,
+      type: this.type,
+      defaults: this.defaults
+    };
+    if (Object.keys(config).length > 0) {
+      base.config = config;
+    }
+    return this.stripSymbols(base);
+  }
+  toDependencyJSON(options) {
+    const json = this.toJSON(options);
+    return json;
+  }
+  hasChildren() {
+    return this._subGraph !== undefined && this._subGraph !== null && this._subGraph.getTasks().length > 0;
+  }
+  _taskAddedListener = () => {
+    this.emit("regenerate");
+  };
+  _subGraph = undefined;
+  set subGraph(subGraph) {
+    if (this._subGraph) {
+      this._subGraph.off("task_added", this._taskAddedListener);
+    }
+    this._subGraph = subGraph;
+    this._subGraph.on("task_added", this._taskAddedListener);
+  }
+  get subGraph() {
+    if (!this._subGraph) {
+      this._subGraph = new TaskGraph;
+      this._subGraph.on("task_added", this._taskAddedListener);
+    }
+    return this._subGraph;
+  }
+  regenerateGraph() {
+    if (this.hasChildren()) {
+      for (const dataflow of this.subGraph.getDataflows()) {
+        this.subGraph.removeDataflow(dataflow);
+      }
+      for (const child of this.subGraph.getTasks()) {
+        this.subGraph.removeTask(child.id);
+      }
+    }
+    this.events.emit("regenerate");
+  }
+}
+
+// src/task-graph/EdgeMaterializer.ts
+import { getLogger as getLogger3 } from "@workglow/util";
+import { previewSource } from "@workglow/util/media";
+class EdgeMaterializer {
+  graph;
+  runner;
+  constructor(graph, runner) {
+    this.graph = graph;
+    this.runner = runner;
+  }
+  filterInputForTask(task, input) {
+    const sourceDataflows = this.graph.getSourceDataflows(task.id);
+    const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
+    const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
+    const filteredInput = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (!connectedInputs.has(key) && !allPortsConnected) {
+        filteredInput[key] = value;
+      }
+    }
+    return filteredInput;
+  }
+  copyInputFromEdgesToNode(task) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    for (const dataflow of dataflows) {
+      const live = dataflow.getCurrentValue();
+      const port = dataflow.targetTaskPortId;
+      let portData;
+      if (port === DATAFLOW_ALL_PORTS) {
+        portData = live;
+      } else if (port === DATAFLOW_ERROR_PORT) {
+        portData = { [DATAFLOW_ERROR_PORT]: dataflow.error };
+      } else {
+        portData = { [port]: live };
+      }
+      this.runner.addInputData(task, portData);
+    }
+  }
+  async pushOutputFromNodeToEdges(node, results) {
+    const dataflows = this.graph.getTargetDataflows(node.id);
+    if (this.runner["previewRunning"] && Object.keys(results).length > 0) {
+      for (const port of Object.keys(results)) {
+        const value = results[port];
+        if (EdgeMaterializer.isImageValueShape(value)) {
+          results[port] = await previewSource(value);
+        }
+      }
+    }
+    for (const dataflow of dataflows) {
+      if (dataflow.stream !== undefined)
+        continue;
+      const registry = this.runner["registry"];
+      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow, registry);
+      if (compatibility === "static") {
+        dataflow.setPortData(results);
+        await dataflow.applyTransforms(registry);
+      } else if (compatibility === "runtime") {
+        const task = this.graph.getTask(dataflow.targetTaskId);
+        const narrowed = await task.narrowInput({ ...results }, registry);
+        dataflow.setPortData(narrowed);
+        await dataflow.applyTransforms(registry);
+      } else {
+        const resultsKeys = Object.keys(results);
+        if (resultsKeys.length > 0) {
+          getLogger3().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+            dataflowId: dataflow.id,
+            compatibility,
+            resultsKeys
+          });
+        }
+      }
     }
-    return obj;
   }
-  canSerializeConfig() {
-    return true;
+  pushErrorFromNodeToEdges(node) {
+    if (!node?.config?.id)
+      return;
+    this.graph.getTargetDataflows(node.id).forEach((dataflow) => {
+      dataflow.error = node.error;
+    });
   }
-  toJSON(_options) {
-    const ctor = this.constructor;
-    if (!this.canSerializeConfig() || !this.originalConfig) {
-      throw new TaskSerializationError(this.type);
-    }
-    const schema = ctor.configSchema();
-    const schemaProperties = typeof schema !== "boolean" && schema?.properties ? schema.properties : {};
-    const config = {};
-    for (const [key, propSchema] of Object.entries(schemaProperties)) {
-      if (key === "id")
-        continue;
-      if (propSchema?.["x-ui-hidden"] === true && key !== "inputSchema" && key !== "outputSchema" && key !== "extras") {
-        continue;
-      }
-      const value = this.originalConfig[key];
-      if (value === undefined)
-        continue;
-      if (typeof value === "function" || typeof value === "symbol")
-        continue;
-      config[key] = value;
-    }
-    if (config.title === ctor.title)
-      delete config.title;
-    if (config.description === ctor.description)
-      delete config.description;
-    const extras = config.extras;
-    if (!extras || Object.keys(extras).length === 0)
-      delete config.extras;
-    const base = {
-      id: this.id,
-      type: this.type,
-      defaults: this.defaults
+  hasErrorOutputEdges(task) {
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
+  }
+  pushErrorOutputToEdges(task) {
+    const taskError = task.error;
+    const errorData = {
+      error: taskError?.message ?? "Unknown error",
+      errorType: taskError?.constructor?.type ?? "TaskError"
     };
-    if (Object.keys(config).length > 0) {
-      base.config = config;
-    }
-    const taskEntitlements = this.entitlements();
-    if (taskEntitlements.entitlements.length > 0) {
-      base.entitlements = taskEntitlements;
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    for (const df of dataflows) {
+      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
+        df.value = errorData;
+        df.setStatus(TaskStatus.COMPLETED);
+      } else {
+        df.setStatus(TaskStatus.DISABLED);
+      }
     }
-    return this.stripSymbols(base);
+    this.runner["runScheduler"].propagateDisabledStatus(this.runner["currentCtx"]);
   }
-  toDependencyJSON(options) {
-    const json = this.toJSON(options);
-    return json;
+  resetTask(graph, task, runId) {
+    task.status = TaskStatus.PENDING;
+    task.resetInputData();
+    task.runOutputData = {};
+    task.error = undefined;
+    task.progress = 0;
+    task.runConfig = { ...task.runConfig, runnerId: runId };
+    this.runner["runScheduler"].pushStatusFromNodeToEdges(task, this.runner["currentCtx"], undefined, graph);
+    if (task?.config?.id) {
+      graph.getTargetDataflows(task.id).forEach((dataflow) => {
+        dataflow.error = task.error;
+      });
+    }
+    task.emit("reset");
+    task.emit("status", task.status);
   }
-  hasChildren() {
-    return this._subGraph !== undefined && this._subGraph !== null && this._subGraph.getTasks().length > 0;
+  static isImageValueShape(v) {
+    if (v === null || typeof v !== "object")
+      return false;
+    const o = v;
+    return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
   }
-  _taskAddedListener = () => {
-    this.emit("regenerate");
-  };
-  _subGraph = undefined;
-  set subGraph(subGraph) {
-    if (this._subGraph) {
-      this._subGraph.off("task_added", this._taskAddedListener);
+}
+
+// src/task-graph/RunContext.ts
+import { uuid4 as uuid43 } from "@workglow/util";
+
+class RunContext {
+  runId;
+  abortController;
+  inProgressTasks = new Map;
+  inProgressFunctions = new Map;
+  failedTaskErrors = new Map;
+  telemetrySpan;
+  graphTimeoutTimer;
+  pendingGraphTimeoutError;
+  activeEnforcer;
+  parentSignalCleanup;
+  constructor(parentSignal) {
+    this.runId = uuid43();
+    this.abortController = new AbortController;
+    if (parentSignal) {
+      const onParentAbort = () => this.abortController.abort();
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+      this.parentSignalCleanup = () => parentSignal.removeEventListener("abort", onParentAbort);
+      if (parentSignal.aborted) {
+        this.parentSignalCleanup();
+        this.parentSignalCleanup = undefined;
+        this.abortController.abort();
+      }
     }
-    this._subGraph = subGraph;
-    this._subGraph.on("task_added", this._taskAddedListener);
   }
-  get subGraph() {
-    if (!this._subGraph) {
-      this._subGraph = new TaskGraph;
-      this._subGraph.on("task_added", this._taskAddedListener);
+  dispose() {
+    this.parentSignalCleanup?.();
+    this.parentSignalCleanup = undefined;
+  }
+}
+
+// src/task-graph/RunScheduler.ts
+import { getLogger as getLogger5 } from "@workglow/util";
+
+// src/task/ConditionalTask.ts
+import { getLogger as getLogger4 } from "@workglow/util";
+
+// src/task/ConditionUtils.ts
+function evaluateCondition(fieldValue, operator, compareValue) {
+  if (fieldValue === null || fieldValue === undefined) {
+    switch (operator) {
+      case "is_empty":
+        return true;
+      case "is_not_empty":
+        return false;
+      case "is_true":
+        return false;
+      case "is_false":
+        return true;
+      default:
+        return false;
     }
-    return this._subGraph;
   }
-  regenerateGraph() {
-    if (this.hasChildren()) {
-      for (const dataflow of this.subGraph.getDataflows()) {
-        this.subGraph.removeDataflow(dataflow);
+  const strValue = String(fieldValue);
+  const numValue = Number(fieldValue);
+  switch (operator) {
+    case "equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue === Number(compareValue);
       }
-      for (const child of this.subGraph.getTasks()) {
-        this.subGraph.removeTask(child.id);
+      return strValue === compareValue;
+    case "not_equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue !== Number(compareValue);
       }
+      return strValue !== compareValue;
+    case "greater_than":
+      return numValue > Number(compareValue);
+    case "greater_or_equal":
+      return numValue >= Number(compareValue);
+    case "less_than":
+      return numValue < Number(compareValue);
+    case "less_or_equal":
+      return numValue <= Number(compareValue);
+    case "contains":
+      return strValue.toLowerCase().includes(compareValue.toLowerCase());
+    case "starts_with":
+      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
+    case "ends_with":
+      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
+    case "is_empty":
+      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
+    case "is_not_empty":
+      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
+    case "is_true":
+      return Boolean(fieldValue) === true;
+    case "is_false":
+      return Boolean(fieldValue) === false;
+    default:
+      return false;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return;
     }
-    this.events.emit("regenerate");
+    current = current[part];
   }
+  return current;
 }
 
 // src/task/ConditionalTask.ts
@@ -3095,7 +3240,7 @@ class ConditionalTask extends Task {
           }
         }
       } catch (error) {
-        getLogger3().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
+        getLogger4().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
       }
     }
     if (this.activeBranches.size === 0 && defaultBranch) {
@@ -3367,7 +3512,7 @@ class RunScheduler {
         ctx.inProgressFunctions.set(Symbol(task.id), runAsync());
       }
     } catch (err) {
-      getLogger4().error("Error running graph", { error: err });
+      getLogger5().error("Error running graph", { error: err });
     }
     await Promise.allSettled(Array.from(ctx.inProgressTasks.values()));
     await Promise.allSettled(Array.from(ctx.inProgressFunctions.values()));
@@ -3443,11 +3588,12 @@ class StreamPump {
     task.on("stream_end", onStreamEnd);
     try {
       const results = await task.runner.run(input, {
-        outputCache: options.outputCache ?? false,
+        outputCache: options.legacyCacheExplicitlyDisabled ? false : options.outputCache,
         shouldAccumulate,
         updateProgress: options.updateProgress,
         registry: options.registry,
-        resourceScope: options.resourceScope
+        resourceScope: options.resourceScope,
+        runId: options.runId
       });
       await this.edgeMaterializer.pushOutputFromNodeToEdges(task, results);
       return {
@@ -3716,10 +3862,14 @@ class TaskGraphRunner {
   previewRunning = false;
   graph;
   outputCache;
+  legacyCacheExplicitlyDisabled = false;
   accumulateLeafOutputs = true;
   registry = globalServiceRegistry3;
   resourceScope;
   currentCtx;
+  runId;
+  currentRunPrivate;
+  baseRegistryForRun;
   edgeMaterializer;
   streamPump;
   runScheduler;
@@ -3759,6 +3909,15 @@ class TaskGraphRunner {
         throw new TaskAbortedError;
       }
       await this.handleComplete();
+      const runPrivateToClean = this.currentRunPrivate;
+      this.currentRunPrivate = undefined;
+      if (runPrivateToClean) {
+        try {
+          await runPrivateToClean.clearRun();
+        } catch (e) {
+          getLogger6().warn("RunPrivateCacheRepo.clearRun failed", { error: e });
+        }
+      }
       return this.filterLeafResults(results);
     } finally {
       if (ownsScope) {
@@ -3830,7 +3989,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.OK);
         previewSpan.end();
-        getLogger5().debug("task graph runPreview timings", {
+        getLogger6().debug("task graph runPreview timings", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings
@@ -3848,7 +4007,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.ERROR, message);
         previewSpan.end();
-        getLogger5().debug("task graph runPreview failed", {
+        getLogger6().debug("task graph runPreview failed", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings,
@@ -3919,14 +4078,17 @@ class TaskGraphRunner {
         outputCache: this.outputCache,
         resourceScope: this.resourceScope,
         accumulateLeafOutputs: this.accumulateLeafOutputs,
-        updateProgress: (t, p, m, ...a) => this.runScheduler.handleProgress(this.currentCtx, t, p, m, ...a)
+        updateProgress: (t, p, m, ...a) => this.runScheduler.handleProgress(this.currentCtx, t, p, m, ...a),
+        runId: this.runId,
+        legacyCacheExplicitlyDisabled: this.legacyCacheExplicitlyDisabled
       });
     }
     const results = await task.runner.run(input, {
-      outputCache: this.outputCache ?? false,
+      outputCache: this.legacyCacheExplicitlyDisabled ? false : this.outputCache,
       updateProgress: async (task2, progress, message, ...args) => await this.runScheduler.handleProgress(this.currentCtx, task2, progress, message, ...args),
       registry: this.registry,
-      resourceScope: this.resourceScope
+      resourceScope: this.resourceScope,
+      runId: this.runId
     });
     await this.edgeMaterializer.pushOutputFromNodeToEdges(task, results);
     return {
@@ -3947,6 +4109,19 @@ class TaskGraphRunner {
       dataflow.reset();
     });
   }
+  static __durabilityWarnedRepos = new WeakSet;
+  static graphUsesPrivatePolicy(graph) {
+    return graph.getTasks().some((t) => {
+      const ctor = t.constructor;
+      if (ctor.cachePolicy?.kind === "private")
+        return true;
+      const proto = ctor.prototype;
+      if (typeof proto.getCachePolicy === "function" && proto.getCachePolicy !== Task.prototype.getCachePolicy) {
+        return true;
+      }
+      return false;
+    });
+  }
   async handleStart(config) {
     if (config?.registry !== undefined) {
       this.registry = config.registry;
@@ -3956,18 +4131,61 @@ class TaskGraphRunner {
     if (config?.resourceScope !== undefined) {
       this.resourceScope = config.resourceScope;
     }
+    this.baseRegistryForRun = this.registry;
+    this.runId = config?.runId;
+    if (this.registry.has(CACHE_REGISTRY)) {
+      const checkRegistry = this.registry.get(CACHE_REGISTRY);
+      if (checkRegistry.private && !checkRegistry.private.isDurable()) {
+        if (TaskGraphRunner.graphUsesPrivatePolicy(this.graph)) {
+          const repo = checkRegistry.private;
+          if (!TaskGraphRunner.__durabilityWarnedRepos.has(repo)) {
+            TaskGraphRunner.__durabilityWarnedRepos.add(repo);
+            getLogger6().warn("TaskGraphRunner: private cache repo may be used but is non-durable \u2014 " + "restart-survival will not work. Ensure the CacheRegistry 'private' " + "slot is backed by a durable storage backend.");
+          }
+        }
+      }
+      if (!this.runId && checkRegistry.private) {
+        if (TaskGraphRunner.graphUsesPrivatePolicy(this.graph)) {
+          throw new TaskConfigurationError("TaskGraphRunner: graph contains a private-policy task but no runId was provided. " + "Provide `runId` in TaskGraphRunConfig so private cache entries can be namespaced.");
+        }
+      }
+    }
+    if (this.runId && this.registry.has(CACHE_REGISTRY)) {
+      const baseRegistry = this.registry.get(CACHE_REGISTRY);
+      if (baseRegistry.private) {
+        const wrappedPrivate = new RunPrivateCacheRepo({
+          backing: baseRegistry.private,
+          runId: this.runId
+        });
+        this.currentRunPrivate = wrappedPrivate;
+        const wrappedRegistry = new DefaultCacheRegistry({
+          deterministic: baseRegistry.deterministic,
+          private: wrappedPrivate
+        });
+        const childContainer = this.registry.container.createChildContainer();
+        const runtimeServices = new ServiceRegistry3(childContainer);
+        runtimeServices.registerInstance(CACHE_REGISTRY, wrappedRegistry);
+        this.registry = runtimeServices;
+        this.resourceScope?.register(`cache:private:${this.runId}`, async () => {});
+      }
+    }
     this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
           this.outputCache = this.registry.get(TASK_OUTPUT_REPOSITORY);
+          this.legacyCacheExplicitlyDisabled = false;
         } else {
           this.outputCache = undefined;
+          this.legacyCacheExplicitlyDisabled = true;
         }
       } else {
         this.outputCache = config.outputCache;
+        this.legacyCacheExplicitlyDisabled = false;
       }
       this.graph.outputCache = this.outputCache;
+    } else {
+      this.legacyCacheExplicitlyDisabled = false;
     }
     if (this.running || this.previewRunning) {
       throw new TaskConfigurationError("Graph is already running");
@@ -4056,6 +4274,10 @@ class TaskGraphRunner {
     }
     ctx?.dispose();
     this.currentCtx = undefined;
+    if (this.baseRegistryForRun !== undefined) {
+      this.registry = this.baseRegistryForRun;
+      this.baseRegistryForRun = undefined;
+    }
     this.graph.emit("complete");
   }
   async handleCompletePreview() {
@@ -4068,6 +4290,7 @@ class TaskGraphRunner {
         return task.abort();
       }
     }));
+    this.currentRunPrivate = undefined;
     const ctx = this.currentCtx;
     this.running = false;
     if (ctx?.telemetrySpan) {
@@ -4077,6 +4300,10 @@ class TaskGraphRunner {
     }
     ctx?.dispose();
     this.currentCtx = undefined;
+    if (this.baseRegistryForRun !== undefined) {
+      this.registry = this.baseRegistryForRun;
+      this.baseRegistryForRun = undefined;
+    }
     this.graph.emit("error", error);
   }
   async handleErrorPreview() {
@@ -4092,6 +4319,7 @@ class TaskGraphRunner {
         return task.abort();
       }
     }));
+    this.currentRunPrivate = undefined;
     const ctx = this.currentCtx;
     if (ctx?.telemetrySpan) {
       ctx.telemetrySpan.setStatus(SpanStatusCode2.ERROR, "aborted");
@@ -4100,6 +4328,10 @@ class TaskGraphRunner {
     }
     ctx?.dispose();
     this.currentCtx = undefined;
+    if (this.baseRegistryForRun !== undefined) {
+      this.registry = this.baseRegistryForRun;
+      this.baseRegistryForRun = undefined;
+    }
     this.graph.emit("abort");
   }
   async handleAbortPreview() {
@@ -4223,7 +4455,7 @@ class GraphAsTask extends Task {
         const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
         this._inputSchemaNode = schemaNode;
       } catch (error) {
-        getLogger6().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
+        getLogger7().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
         this._inputSchemaNode = compileSchema2({});
       }
     }
@@ -4507,7 +4739,7 @@ function convertPipeFunctionToTask(fn, config) {
         additionalProperties: true
       };
     };
-    static cacheable = false;
+    static cachePolicy = { kind: "none" };
     async execute(input, context) {
       return fn(input, context);
     }
@@ -4590,7 +4822,8 @@ class TaskGraph {
       timeout: config?.timeout,
       maxTasks: config?.maxTasks,
       resourceScope: config?.resourceScope,
-      disposeStrategy: config?.disposeStrategy
+      disposeStrategy: config?.disposeStrategy,
+      runId: config?.runId
     });
   }
   runPreview(input = {}, config = {}) {
@@ -5139,7 +5372,7 @@ function autoConnect(graph, sourceTask, targetTask, options) {
 }
 
 // src/task-graph/LoopBuilderContext.ts
-import { getLogger as getLogger7 } from "@workglow/util";
+import { getLogger as getLogger8 } from "@workglow/util";
 function runLoopAutoConnect(parentGraph, pending) {
   const { parent, iteratorTask } = pending;
   if (parentGraph.getTargetDataflows(parent.id).length !== 0)
@@ -5153,7 +5386,7 @@ function runLoopAutoConnect(parentGraph, pending) {
   const result = autoConnect(parentGraph, parent, iteratorTask, { earlierTasks });
   if (result.error) {
     const message = result.error + " Task not added.";
-    getLogger7().error(message);
+    getLogger8().error(message);
     parentGraph.removeTask(iteratorTask.id);
     return message;
   }
@@ -5192,7 +5425,7 @@ class LoopBuilderContext {
 }
 
 // src/task-graph/WorkflowBuilder.ts
-import { getLogger as getLogger8, uuid4 as uuid47 } from "@workglow/util";
+import { getLogger as getLogger9, uuid4 as uuid47 } from "@workglow/util";
 
 // src/task-graph/ConditionalBuilder.ts
 import { uuid4 as uuid46 } from "@workglow/util";
@@ -5351,7 +5584,7 @@ class WorkflowBuilder {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger8().error(this._error);
+          getLogger9().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -5376,10 +5609,10 @@ class WorkflowBuilder {
       if (result.error) {
         if (this._loopContext !== undefined) {
           this._error = result.error;
-          getLogger8().warn(this._error);
+          getLogger9().warn(this._error);
         } else {
           this._error = result.error + " Task not added.";
-          getLogger8().error(this._error);
+          getLogger9().error(this._error);
           this._facade.graph.removeTask(task.id);
         }
       }
@@ -5402,7 +5635,7 @@ class WorkflowBuilder {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger8().error(this._error);
+          getLogger9().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -5454,7 +5687,7 @@ class WorkflowBuilder {
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
       this._error = errorMsg;
-      getLogger8().error(this._error);
+      getLogger9().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const lastNode = nodes[nodes.length + index];
@@ -5463,13 +5696,13 @@ class WorkflowBuilder {
       if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
         const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
         this._error = errorMsg;
-        getLogger8().error(this._error);
+        getLogger9().error(this._error);
         throw new WorkflowError(errorMsg);
       }
     } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
       const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
       this._error = errorMsg;
-      getLogger8().error(this._error);
+      getLogger9().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const df = new Dataflow(lastNode.id, source, undefined, target);
@@ -5482,7 +5715,7 @@ class WorkflowBuilder {
     const parent = getLastTask(this._facade);
     if (!parent) {
       this._error = "onError() requires a preceding task in the workflow";
-      getLogger8().error(this._error);
+      getLogger9().error(this._error);
       throw new WorkflowError(this._error);
     }
     const handlerTask = ensureTask(handler);
@@ -5496,7 +5729,7 @@ class WorkflowBuilder {
     const nodes = this._facade.graph.getTasks();
     if (nodes.length === 0) {
       this._error = "No tasks to remove";
-      getLogger8().error(this._error);
+      getLogger9().error(this._error);
       return;
     }
     const lastNode = nodes[nodes.length - 1];
@@ -6460,7 +6693,7 @@ function registerBuiltInTransforms() {
     TransformRegistry.registerTransform(t);
 }
 // src/task/EntitlementProfile.ts
-import { createServiceToken as createServiceToken5 } from "@workglow/util";
+import { createServiceToken as createServiceToken6 } from "@workglow/util";
 var STATIC_SIGNAL_SOURCE = Object.freeze({
   subscribe(_listener) {
     return () => {};
@@ -6563,7 +6796,7 @@ function createPolicyProfile(name, policy, options = {}) {
   };
   return profile;
 }
-var ENTITLEMENT_PROFILE = createServiceToken5("workglow.entitlementProfile");
+var ENTITLEMENT_PROFILE = createServiceToken6("workglow.entitlementProfile");
 // src/task/EntitlementProfiles.ts
 var BROWSER_GRANTS = [
   { id: Entitlements.NETWORK_HTTP },
@@ -8185,8 +8418,8 @@ import {
   JobQueueClient,
   JobQueueServer
 } from "@workglow/job-queue";
-import { createServiceToken as createServiceToken6, globalServiceRegistry as globalServiceRegistry4 } from "@workglow/util";
-var JOB_QUEUE_FACTORY = createServiceToken6("taskgraph.jobQueueFactory");
+import { createServiceToken as createServiceToken7, globalServiceRegistry as globalServiceRegistry4 } from "@workglow/util";
+var JOB_QUEUE_FACTORY = createServiceToken7("taskgraph.jobQueueFactory");
 var defaultJobQueueFactory = async ({
   queueName,
   jobClass,
@@ -8451,8 +8684,8 @@ queueMicrotask(() => {
 });
 // src/task/TaskRegistry.ts
 import {
-  createServiceToken as createServiceToken7,
-  getLogger as getLogger9,
+  createServiceToken as createServiceToken8,
+  getLogger as getLogger10,
   globalServiceRegistry as globalServiceRegistry5,
   registerInputCompactor,
   registerInputResolver
@@ -8475,7 +8708,7 @@ function registerTask(baseClass) {
     const result = validateSchema(schema);
     if (!result.valid) {
       const messages = result.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
-      getLogger9().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
+      getLogger10().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
         taskType: baseClass.type,
         schemaName: name,
         errors: result.errors
@@ -8491,7 +8724,7 @@ var TaskRegistry = {
   registerTask,
   unregisterTask
 };
-var TASK_CONSTRUCTORS = createServiceToken7("task.constructors");
+var TASK_CONSTRUCTORS = createServiceToken8("task.constructors");
 function getGlobalTaskConstructors() {
   return globalServiceRegistry5.get(TASK_CONSTRUCTORS);
 }
@@ -8660,8 +8893,8 @@ var registerBaseTasks = () => {
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken8, EventEmitter as EventEmitter7 } from "@workglow/util";
-var TASK_GRAPH_REPOSITORY = createServiceToken8("taskgraph.taskGraphRepository");
+import { createServiceToken as createServiceToken9, EventEmitter as EventEmitter7 } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken9("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
@@ -8757,6 +8990,10 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
     this.tabularRepository = tabularRepository;
     this.outputCompression = outputCompression;
   }
+  isDurable() {
+    const backing = this.tabularRepository;
+    return backing.isDurable?.() ?? true;
+  }
   async setupDatabase() {
     await this.tabularRepository.setupDatabase?.();
   }
@@ -8817,6 +9054,33 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
     await this.tabularRepository.deleteSearch({ createdAt: { value: date, operator: "<" } });
     this.emit("output_pruned");
   }
+  async deleteByTaskTypePrefix(prefix) {
+    for await (const row of this.tabularRepository.records()) {
+      if (typeof row.taskType === "string" && row.taskType.startsWith(prefix)) {
+        await this.tabularRepository.delete({ key: row.key, taskType: row.taskType });
+      }
+    }
+  }
+  async clearOlderThanWithTaskTypePrefix(prefix, olderThanInMs) {
+    const cutoff = Date.now() - olderThanInMs;
+    for await (const row of this.tabularRepository.records()) {
+      if (typeof row.taskType === "string" && row.taskType.startsWith(prefix)) {
+        const ts = typeof row.createdAt === "string" ? new Date(row.createdAt).getTime() : NaN;
+        if (!isNaN(ts) && ts < cutoff) {
+          await this.tabularRepository.delete({ key: row.key, taskType: row.taskType });
+        }
+      }
+    }
+  }
+  async sizeByTaskTypePrefix(prefix) {
+    let count = 0;
+    for await (const row of this.tabularRepository.records()) {
+      if (typeof row.taskType === "string" && row.taskType.startsWith(prefix)) {
+        count++;
+      }
+    }
+    return count;
+  }
 }
 // src/storage/PortCodecRegistry.ts
 import { _resetPortCodecsForTests, getPortCodec as getPortCodec2, registerPortCodec } from "@workglow/util";
@@ -8866,6 +9130,8 @@ export {
   isoDateToUnixTransform,
   isTaskStreamable,
   isStrictArraySchema,
+  isPolicyPrivate,
+  isPolicyCached,
   isIterationProperty,
   isFlexibleSchema,
   indexTransform,
@@ -8979,6 +9245,7 @@ export {
   STATIC_SIGNAL_SOURCE,
   SERVER_GRANTS,
   RunScheduler,
+  RunPrivateCacheRepo,
   RunContext,
   ReduceTask,
   PROPERTY_ARRAY,
@@ -9006,10 +9273,12 @@ export {
   ENTITLEMENT_ENFORCER,
   EMPTY_POLICY,
   EMPTY_ENTITLEMENTS,
+  DefaultCacheRegistry,
   DataflowArrow,
   Dataflow,
   DESKTOP_GRANTS,
   DENY_ALL_RESOLVER,
+  DEFAULT_CACHE_POLICY,
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
@@ -9017,8 +9286,10 @@ export {
   CreateEndLoopWorkflow,
   CreateAdaptiveWorkflow,
   ConditionalTask,
+  CacheJanitor,
   CacheCoordinator,
+  CACHE_REGISTRY,
   BROWSER_GRANTS
 };
 
-//# debugId=538855DC693E4A3D64756E2164756E21
+//# debugId=E2522767BD1162D964756E2164756E21