@sanity/workflow-engine 0.10.0 → 0.12.0

package/dist/index.cjs

@@ -123,7 +123,7 @@ function isGdr(value) {
   return typeof value == "object" && value !== null && typeof value.id == "string" && typeof value.type == "string";
 }
 function buildParams(args) {
-  const { instance, now, snapshot, extra } = args, currentTasks2 = findOpenStageEntry(instance)?.tasks ?? [];
+  const { instance, now, snapshot, extra } = args, currentActivities2 = findOpenStageEntry(instance)?.activities ?? [];
   return {
     self: selfGdr(instance),
     fields: renderedFields(instance.fields ?? [], snapshot),
@@ -134,10 +134,12 @@ function buildParams(args) {
     /** `$effects` — parent context handoff by entry name, completed-effect
      *  outputs namespaced under the effect's name (`$effects['x.y'].out`). */
     effects: effectsContextMap(instance),
-    /** `$tasks` — the current stage's task rows, statuses included. */
-    tasks: currentTasks2,
-    allTasksDone: currentTasks2.every((t) => t.status === "done" || t.status === "skipped"),
-    anyTaskFailed: currentTasks2.some((t) => t.status === "failed"),
+    /** `$activities` — the current stage's activity rows, statuses included. */
+    activities: currentActivities2,
+    allActivitiesDone: currentActivities2.every(
+      (activity) => activity.status === "done" || activity.status === "skipped"
+    ),
+    anyActivityFailed: currentActivities2.some((activity) => activity.status === "failed"),
     ...extra
   };
 }
@@ -149,15 +151,15 @@ function renderedFields(entries, snapshot) {
 function renderedValue(entry, snapshot) {
   return entry._type !== "doc.ref" || entry.value === null || snapshot === void 0 ? entry.value : snapshot.docs.find((d) => d._id === entry.value.id) ?? entry.value;
 }
-function scopedFieldOverlay(instance, snapshot, taskName) {
+function scopedFieldOverlay(instance, snapshot, activityName) {
   const stageEntry = findOpenStageEntry(instance);
   if (stageEntry === void 0) return {};
-  const stageFields = renderedFields(stageEntry.fields ?? [], snapshot), task = taskName ? stageEntry.tasks.find((t) => t.name === taskName) : void 0;
-  return { ...stageFields, ...renderedFields(task?.fields ?? [], snapshot) };
+  const stageFields = renderedFields(stageEntry.fields ?? [], snapshot), activity = activityName ? stageEntry.activities.find((t) => t.name === activityName) : void 0;
+  return { ...stageFields, ...renderedFields(activity?.fields ?? [], snapshot) };
 }
-function assignedFor(instance, taskName, actor, roleAliases) {
+function assignedFor(instance, activityName, actor, roleAliases) {
   if (actor === void 0) return !1;
-  const entry = findOpenStageEntry(instance)?.tasks.find((t) => t.name === taskName)?.fields?.find((s) => s._type === "assignees");
+  const entry = findOpenStageEntry(instance)?.activities.find((t) => t.name === activityName)?.fields?.find((s) => s._type === "assignees");
   return entry === void 0 ? !1 : entry.value.some(
     (a) => a.type === "user" ? a.id === actor.id : schema.actorFulfillsRole(actor.roles, a.role, roleAliases)
   );
@@ -289,7 +291,7 @@ function validateDefinition(definition) {
     validateStage(v2, stage);
   if (v2.errors.length > 0)
     throw new Error(
-      `defineWorkflow("${definition.name}", v${definition.version}): ${v2.errors.length} validation error${v2.errors.length === 1 ? "" : "s"}:
+      `defineWorkflow("${definition.name}"): ${v2.errors.length} validation error${v2.errors.length === 1 ? "" : "s"}:
 ` + v2.errors.join(`
 `)
     );
@@ -310,7 +312,7 @@ function createDefinitionValidator() {
   return { errors, tryParse, checkCondition: (groq, where) => {
     tryParse(groq, where), rejectTypeScan(groq, where);
   }, checkEntry: (entry, label) => {
-    entry.source.type === "query" && tryParse(entry.source.query, `${label}.query`);
+    entry.initialValue?.type === "query" && tryParse(entry.initialValue.query, `${label}.query`);
   }, checkGuardRead: (expr, where) => {
     isGuardReadExpr(expr) || errors.push(
       `  \xB7 ${where}: guard read "${expr}" is not a supported deploy-time value \u2014 use "$self", "$now", "$fields.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $fields or $effects)`
@@ -327,8 +329,8 @@ function validateStage(v2, stage) {
     for (const [key, groq] of effectBindings(t.effects))
       v2.tryParse(groq, `transition "${t.name}" effect binding "${key}"`);
   }
-  for (const task of stage.tasks ?? [])
-    validateTask(v2, stage.name, task);
+  for (const activity of stage.activities ?? [])
+    validateActivity(v2, stage.name, activity);
 }
 function validateGuardReads(v2, stageName, guard) {
   const where = `stage "${stageName}" guard "${guard.name}"`;
@@ -337,22 +339,22 @@ function validateGuardReads(v2, stageName, guard) {
   for (const [key, expr] of Object.entries(guard.metadata ?? {}))
     v2.checkGuardRead(expr, `${where} metadata "${key}"`);
 }
-function validateTask(v2, stageName, task) {
-  const where = `stage "${stageName}" task "${task.name}"`;
-  for (const entry of task.fields ?? [])
+function validateActivity(v2, stageName, activity) {
+  const where = `stage "${stageName}" activity "${activity.name}"`;
+  for (const entry of activity.fields ?? [])
     v2.checkEntry(entry, `${where}.fields "${entry.name}"`);
-  task.filter !== void 0 && v2.checkCondition(task.filter, `${where}.filter`), task.completeWhen !== void 0 && v2.checkCondition(task.completeWhen, `${where}.completeWhen`), task.failWhen !== void 0 && v2.checkCondition(task.failWhen, `${where}.failWhen`);
-  for (const [name, groq] of Object.entries(task.requirements ?? {}))
+  activity.filter !== void 0 && v2.checkCondition(activity.filter, `${where}.filter`), activity.completeWhen !== void 0 && v2.checkCondition(activity.completeWhen, `${where}.completeWhen`), activity.failWhen !== void 0 && v2.checkCondition(activity.failWhen, `${where}.failWhen`);
+  for (const [name, groq] of Object.entries(activity.requirements ?? {}))
     v2.checkCondition(groq, `${where}.requirements "${name}"`);
-  for (const [key, groq] of effectBindings(task.effects))
+  for (const [key, groq] of effectBindings(activity.effects))
     v2.tryParse(groq, `${where} effect binding "${key}"`);
-  validateTaskActions(v2, task), task.subworkflows !== void 0 && validateSubworkflows(v2, where, task.subworkflows);
+  validateActivityActions(v2, activity), activity.subworkflows !== void 0 && validateSubworkflows(v2, where, activity.subworkflows);
 }
-function validateTaskActions(v2, task) {
-  for (const a of task.actions ?? []) {
-    a.filter !== void 0 && v2.checkCondition(a.filter, `task "${task.name}" action "${a.name}".filter`);
+function validateActivityActions(v2, activity) {
+  for (const a of activity.actions ?? []) {
+    a.filter !== void 0 && v2.checkCondition(a.filter, `activity "${activity.name}" action "${a.name}".filter`);
     for (const [key, groq] of effectBindings(a.effects))
-      v2.tryParse(groq, `task "${task.name}" action "${a.name}" effect binding "${key}"`);
+      v2.tryParse(groq, `activity "${activity.name}" action "${a.name}" effect binding "${key}"`);
   }
 }
 function validateSubworkflows(v2, where, sub) {
@@ -367,10 +369,10 @@ function effectBindings(effects) {
     (e) => Object.entries(e.bindings ?? {}).map(([k, groq]) => [`${e.name}.${k}`, groq])
   );
 }
-function actionVerdict(task, action) {
+function actionVerdict(activity, action) {
   return {
-    task: task.task.name,
-    taskStatus: task.status,
+    activity: activity.activity.name,
+    activityStatus: activity.status,
     action: action.action.name,
     title: action.action.title,
     allowed: action.allowed,
@@ -378,8 +380,8 @@ function actionVerdict(task, action) {
     params: action.action.params ?? []
   };
 }
-function availableActions(tasks) {
-  return tasks.flatMap((t) => t.actions.map((a) => actionVerdict(t, a)));
+function availableActions(activities) {
+  return activities.flatMap((t) => t.actions.map((a) => actionVerdict(t, a)));
 }
 const wallClock = () => (/* @__PURE__ */ new Date()).toISOString(), GUARD_DOC_TYPE = "temp.system.guard";
 class MutationGuardDeniedError extends Error {
@@ -501,60 +503,67 @@ function diagnoseInputFromEvaluation(evaluation) {
   const stage = openStage(evaluation.instance);
   return {
     instance: evaluation.instance,
-    tasks: evaluation.currentStage.tasks,
+    activities: evaluation.currentStage.activities,
     transitions: evaluation.currentStage.transitions,
     assignees: Object.fromEntries(
-      evaluation.currentStage.tasks.map((t) => [t.task.name, assigneesOf(stage, t.task.name)])
+      evaluation.currentStage.activities.map((t) => [
+        t.activity.name,
+        assigneesOf(stage, t.activity.name)
+      ])
     )
   };
 }
 function openStage(instance) {
   return findOpenStageEntry(instance);
 }
-function assigneesOf(stage, taskName) {
-  return (stage?.tasks.find((t) => t.name === taskName)?.fields ?? []).filter((s) => s._type === "assignees").flatMap((s) => s.value);
+function assigneesOf(stage, activityName) {
+  return (stage?.activities.find((t) => t.name === activityName)?.fields ?? []).filter((s) => s._type === "assignees").flatMap((s) => s.value);
 }
 function isResolved(status) {
   return status === "done" || status === "skipped";
 }
 function failedEffectCause(input) {
-  const stalled = new Set(input.tasks.filter((t) => !isResolved(t.status)).map((t) => t.task.name)), effect = [...input.instance.effectHistory].reverse().find((e) => e.status === "failed" && e.origin.kind === "task" && stalled.has(e.origin.name));
+  const stalled = new Set(
+    input.activities.filter((t) => !isResolved(t.status)).map((t) => t.activity.name)
+  ), effect = [...input.instance.effectHistory].reverse().find(
+    (e) => e.status === "failed" && e.origin.kind === "activity" && stalled.has(e.origin.name)
+  );
   return effect ? { kind: "failed-effect", effect } : void 0;
 }
 function hungEffectCause(input) {
   const effect = input.instance.pendingEffects.find((e) => e.claim !== void 0);
   return effect ? { kind: "hung-effect", effect } : void 0;
 }
-function failedTaskCause(input) {
-  const failed = input.tasks.find((t) => t.status === "failed");
-  return failed ? { kind: "failed-task", task: failed.task.name } : void 0;
+function failedActivityCause(input) {
+  const failed = input.activities.find((t) => t.status === "failed");
+  return failed ? { kind: "failed-activity", activity: failed.activity.name } : void 0;
 }
 function waitingState(input) {
-  const active = input.tasks.find(
-    (t) => t.status === "active" && (t.task.actions ?? []).length > 0 && (t.unmetRequirements ?? []).length === 0
+  const active = input.activities.find(
+    (t) => t.status === "active" && (t.activity.actions ?? []).length > 0 && (t.unmetRequirements ?? []).length === 0
   );
   if (active !== void 0)
     return {
       state: "waiting",
-      task: active.task.name,
-      assignees: input.assignees[active.task.name] ?? [],
-      actions: (active.task.actions ?? []).map((a) => a.name)
+      activity: active.activity.name,
+      assignees: input.assignees[active.activity.name] ?? [],
+      actions: (active.activity.actions ?? []).map((a) => a.name)
     };
 }
 function blockedState(input) {
-  const blocked = input.tasks.find(
-    (t) => t.status === "active" && (t.task.actions ?? []).length > 0 && (t.unmetRequirements ?? []).length > 0
+  const blocked = input.activities.find(
+    (t) => t.status === "active" && (t.activity.actions ?? []).length > 0 && (t.unmetRequirements ?? []).length > 0
   );
   if (blocked !== void 0)
     return {
       state: "blocked",
-      task: blocked.task.name,
+      activity: blocked.activity.name,
       requirements: blocked.unmetRequirements ?? [],
-      assignees: input.assignees[blocked.task.name] ?? []
+      assignees: input.assignees[blocked.activity.name] ?? []
     };
 }
 function noTransitionFiresCause(input) {
-  if (input.transitions.length === 0 || input.transitions.some((t) => t.filterSatisfied) || !input.tasks.every((t) => isResolved(t.status)))
+  if (input.transitions.length === 0 || input.transitions.some((t) => t.filterSatisfied) || !input.activities.every((t) => isResolved(t.status)))
     return;
   const undecidable = input.transitions.filter((t) => t.unevaluable);
   return undecidable.length > 0 ? { kind: "transition-unevaluable", transitions: undecidable.map((t) => t.transition.name) } : { kind: "no-transition-fires" };
@@ -567,7 +576,7 @@ function diagnoseInstance(input) {
   }
   if (instance.completedAt !== void 0)
     return { state: "completed", at: instance.completedAt };
-  const cause = failedEffectCause(input) ?? failedTaskCause(input) ?? hungEffectCause(input) ?? noTransitionFiresCause(input);
+  const cause = failedEffectCause(input) ?? failedActivityCause(input) ?? hungEffectCause(input) ?? noTransitionFiresCause(input);
   return cause !== void 0 ? { state: "stuck", cause } : waitingState(input) ?? blockedState(input) ?? { state: "progressing" };
 }
 const RUNNABLE_VERBS = /* @__PURE__ */ new Set(["set-stage", "abort"]);
@@ -589,12 +598,12 @@ function remediationsForCause(cause) {
         },
         { verb: "abort", rationale: "Abort the instance if the effect never drains." }
       ];
-    case "failed-task":
+    case "failed-activity":
       return [
-        { verb: "reset-task", rationale: "Reset or skip the failed task." },
+        { verb: "reset-activity", rationale: "Reset or skip the failed activity." },
         {
           verb: "set-stage",
-          rationale: "Move the instance past the failed task to the intended next stage."
+          rationale: "Move the instance past the failed activity to the intended next stage."
         }
       ];
     case "no-transition-fires":
@@ -616,13 +625,15 @@ function remediationsFor(diagnosis) {
 }
 class ActionParamsInvalidError extends Error {
   action;
-  task;
+  activity;
   issues;
   constructor(args) {
     const lines = args.issues.map((i) => `  - ${i.param}: ${i.reason}`).join(`
 `);
-    super(`Action "${args.action}" on task "${args.task}" rejected: invalid params
-${lines}`), this.name = "ActionParamsInvalidError", this.action = args.action, this.task = args.task, this.issues = args.issues;
+    super(
+      `Action "${args.action}" on activity "${args.activity}" rejected: invalid params
+${lines}`
+    ), this.name = "ActionParamsInvalidError", this.action = args.action, this.activity = args.activity, this.issues = args.issues;
   }
 }
 class RequiredFieldNotProvidedError extends Error {
@@ -632,7 +643,7 @@ class RequiredFieldNotProvidedError extends Error {
     const lines = args.missing.map((m) => `  - ${m.name} (${m.type})`).join(`
 `), where = args.definition !== void 0 ? ` for workflow "${args.definition}"` : "";
     super(
-      `Required init fields${where} was not provided:
+      `Required input fields${where} were not provided:
 ${lines}
 Provide each via \`initialFields\` when starting standalone, or via the parent's \`subworkflows.with\` when spawned.`
     ), this.name = "RequiredFieldNotProvidedError", args.definition !== void 0 && (this.definition = args.definition), this.missing = args.missing;
@@ -664,13 +675,13 @@ class PartialGuardDeployError extends Error {
 const CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS = 3;
 class ConcurrentFireActionError extends Error {
   instanceId;
-  task;
+  activity;
   action;
   attempts;
   constructor(args) {
     super(
-      `Action "${args.action}" on task "${args.task}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running \u2014 a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`
-    ), this.name = "ConcurrentFireActionError", this.instanceId = args.instanceId, this.task = args.task, this.action = args.action, this.attempts = args.attempts;
+      `Action "${args.action}" on activity "${args.activity}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running \u2014 a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`
+    ), this.name = "ConcurrentFireActionError", this.instanceId = args.instanceId, this.activity = args.activity, this.action = args.action, this.attempts = args.attempts;
   }
 }
 function isRevisionConflict(error) {
@@ -683,7 +694,7 @@ class ConcurrentEditFieldError extends Error {
   target;
   attempts;
   constructor(args) {
-    const where = args.target.task !== void 0 ? `${args.target.task}.${args.target.field}` : args.target.field;
+    const where = args.target.activity !== void 0 ? `${args.target.activity}.${args.target.field}` : args.target.field;
     super(
       `Edit of "${args.target.scope}:${where}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running \u2014 a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`
     ), this.name = "ConcurrentEditFieldError", this.instanceId = args.instanceId, this.target = args.target, this.attempts = args.attempts;
@@ -761,6 +772,9 @@ function subscriptionDocumentsForInstance(instance) {
     ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
   };
 }
+function instanceWatchesDocument(instance, document) {
+  return collectWatchRefs(instance).some((ref) => ref.id === document);
+}
 function entryDocRefs(entries) {
   return fieldEntries(entries).flatMap((entry) => entry._type === "doc.ref" ? isGdr(entry.value) ? [entry.value] : [] : entry._type === "doc.refs" ? Array.isArray(entry.value) ? entry.value.filter(isGdr) : [] : []);
 }
@@ -875,14 +889,14 @@ function guardIdRefs(definition) {
 function staticIdRefGdr(idRef, stage, definition) {
   const read = /^\$fields\.([\w-]+)/.exec(idRef);
   if (read === null) return;
-  const source = entriesInScope(stage, definition).find((e) => e.name === read[1])?.source;
-  return source?.type === "literal" ? gdrFromValue(source.value) : void 0;
+  const seed = entriesInScope(stage, definition).find((e) => e.name === read[1])?.initialValue;
+  return seed?.type === "literal" ? gdrFromValue(seed.value) : void 0;
 }
 function entriesInScope(stage, definition) {
   return [
     ...definition.fields ?? [],
     ...stage.fields ?? [],
-    ...(stage.tasks ?? []).flatMap((task) => task.fields ?? [])
+    ...(stage.activities ?? []).flatMap((activity) => activity.fields ?? [])
   ];
 }
 function gdrFromValue(value) {
@@ -1064,76 +1078,73 @@ const GdrShape = v__namespace.looseObject({
 }), AssigneeShape = v__namespace.union([
   v__namespace.looseObject({ type: v__namespace.literal("user"), id: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)) }),
   v__namespace.looseObject({ type: v__namespace.literal("role"), role: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)) })
-]), ChecklistItemShape = v__namespace.looseObject({
-  label: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)),
-  done: v__namespace.boolean(),
-  doneBy: v__namespace.optional(v__namespace.string()),
-  doneAt: v__namespace.optional(v__namespace.string()),
-  _key: v__namespace.optional(v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)))
-}), NoteItemShape = v__namespace.pipe(
-  v__namespace.looseObject({
-    _key: v__namespace.optional(v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)))
-  }),
-  v__namespace.check(
-    (val) => typeof val == "object" && val !== null && !Array.isArray(val),
-    "must be an object"
-  )
-), NullableString = v__namespace.union([v__namespace.null(), v__namespace.string()]), NullableNumber = v__namespace.union([v__namespace.null(), v__namespace.number()]), NullableBoolean = v__namespace.union([v__namespace.null(), v__namespace.boolean()]), NullableDateTime = v__namespace.union([
+]), NullableString = v__namespace.union([v__namespace.null(), v__namespace.string()]), NullableNumber = v__namespace.union([v__namespace.null(), v__namespace.number()]), NullableBoolean = v__namespace.union([v__namespace.null(), v__namespace.boolean()]), NullableDateTime = v__namespace.union([
   v__namespace.null(),
   v__namespace.pipe(
     v__namespace.string(),
     v__namespace.check((s) => !Number.isNaN(Date.parse(s)), "must be an ISO-8601 datetime string")
   )
+]), NullableDate = v__namespace.union([
+  v__namespace.null(),
+  v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date"))
 ]), NullableUrl = NullableString, valueSchemas = {
   "doc.ref": v__namespace.union([v__namespace.null(), GdrShape]),
   "doc.refs": v__namespace.array(GdrShape),
   "release.ref": v__namespace.union([v__namespace.null(), ReleaseRefShape]),
   query: v__namespace.any(),
-  "value.string": NullableString,
-  "value.url": NullableUrl,
-  "value.number": NullableNumber,
-  "value.boolean": NullableBoolean,
-  "value.dateTime": NullableDateTime,
-  "value.actor": v__namespace.union([v__namespace.null(), ActorShape]),
-  checklist: v__namespace.array(ChecklistItemShape),
-  notes: v__namespace.array(NoteItemShape),
+  string: NullableString,
+  text: NullableString,
+  number: NullableNumber,
+  boolean: NullableBoolean,
+  date: NullableDate,
+  datetime: NullableDateTime,
+  url: NullableUrl,
+  actor: v__namespace.union([v__namespace.null(), ActorShape]),
+  assignee: v__namespace.union([v__namespace.null(), AssigneeShape]),
   assignees: v__namespace.array(AssigneeShape)
-}, itemSchemas = {
-  "doc.refs": GdrShape,
-  checklist: ChecklistItemShape,
-  notes: NoteItemShape,
-  assignees: AssigneeShape
 };
-function isAppendable(entryType) {
-  return entryType in itemSchemas;
+function shapeValueSchema(shape) {
+  return shape.type === "object" ? objectSchema(shape.fields ?? []) : shape.type === "array" ? v__namespace.array(objectSchema(shape.of ?? [])) : valueSchemas[shape.type] ?? v__namespace.any();
 }
-function validateFieldValue(args) {
-  const schema2 = valueSchemas[args.entryType];
-  if (schema2 === void 0)
-    throw new FieldValueShapeError({
-      entryType: args.entryType,
-      entryName: args.entryName,
-      issues: [`unknown field entry type ${args.entryType}`],
-      mode: "value"
-    });
+function objectSchema(fields) {
+  const entries = /* @__PURE__ */ Object.create(null);
+  for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema(f));
+  return v__namespace.looseObject(entries);
+}
+function wholeValueSchema(entryType, shape) {
+  return entryType === "object" ? v__namespace.union([v__namespace.null(), objectSchema(shape.fields ?? [])]) : entryType === "array" ? v__namespace.array(objectSchema(shape.of ?? [])) : valueSchemas[entryType];
+}
+function appendItemSchema(entryType, shape) {
+  if (entryType === "array") return objectSchema(shape.of ?? []);
+  if (entryType === "doc.refs") return GdrShape;
+  if (entryType === "assignees") return AssigneeShape;
+}
+function checkFieldValue(args) {
+  const schema2 = wholeValueSchema(args.entryType, args);
+  if (schema2 === void 0) return [`unknown field entry type ${args.entryType}`];
   const result = v__namespace.safeParse(schema2, args.value);
-  if (!result.success)
+  return result.success ? void 0 : formatIssues(result.issues);
+}
+function validateFieldValue(args) {
+  const issues = checkFieldValue(args);
+  if (issues !== void 0)
     throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
-      issues: formatIssues(result.issues),
+      issues,
       mode: "value"
     });
 }
 function validateFieldAppendItem(args) {
-  if (!isAppendable(args.entryType))
+  const schema2 = appendItemSchema(args.entryType, args);
+  if (schema2 === void 0)
     throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
       issues: [`field entry type ${args.entryType} does not support append`],
       mode: "item"
     });
-  const schema2 = itemSchemas[args.entryType], result = v__namespace.safeParse(schema2, args.item);
+  const result = v__namespace.safeParse(schema2, args.item);
   if (!result.success)
     throw new FieldValueShapeError({
       entryType: args.entryType,
@@ -1161,7 +1172,7 @@ function derivePerspectiveFromFields(entries) {
 async function resolveDeclaredFields(args) {
   const { entryDefs, initialFields, ctx, randomKey: randomKey2 } = args;
   if (entryDefs === void 0 || entryDefs.length === 0) return [];
-  assertRequiredInitProvided(entryDefs, initialFields, ctx.definitionName);
+  assertRequiredInputProvided(entryDefs, initialFields, ctx.definitionName);
   const out = [];
   for (const entry of entryDefs) {
     const scopedCtx = { ...ctx, resolvedFields: out };
@@ -1169,8 +1180,8 @@ async function resolveDeclaredFields(args) {
   }
   return out;
 }
-function assertRequiredInitProvided(entryDefs, initialFields, definitionName) {
-  const missing = entryDefs.filter((entry) => entry.required === !0 && entry.source.type === "init").filter((entry) => {
+function assertRequiredInputProvided(entryDefs, initialFields, definitionName) {
+  const missing = entryDefs.filter((entry) => entry.required === !0 && entry.initialValue?.type === "input").filter((entry) => {
     const match = initialFields.find((s) => s.name === entry.name && s.type === entry.type);
     return match === void 0 || match.value === void 0 || match.value === null;
   }).map((entry) => ({ name: entry.name, type: entry.type }));
@@ -1180,18 +1191,13 @@ function assertRequiredInitProvided(entryDefs, initialFields, definitionName) {
       missing
     });
 }
-const ARRAY_SLOT_TYPES = /* @__PURE__ */ new Set([
-  "doc.refs",
-  "checklist",
-  "notes",
-  "assignees"
-]);
+const ARRAY_SLOT_TYPES = /* @__PURE__ */ new Set(["doc.refs", "array", "assignees"]);
 function defaultEntryValue(entryType) {
   return ARRAY_SLOT_TYPES.has(entryType) ? [] : null;
 }
-function resolveInitValue(entry, initialFields, defaultValue) {
+function resolveInputValue(entry, initialFields, defaultValue) {
   const initMatch = initialFields.find((s) => s.name === entry.name && s.type === entry.type);
-  return initMatch === void 0 ? defaultValue : (assertInitValueShape(entry, initMatch.value), initMatch.value);
+  return initMatch === void 0 ? defaultValue : (assertInputValueShape(entry, initMatch.value), initMatch.value);
 }
 function resolveFieldReadValue(source, ctx, defaultValue) {
   const target = (source.scope === "workflow" ? ctx.workflowFields ?? [] : ctx.resolvedFields ?? []).find((s) => s.name === source.field), targetValue = target === void 0 ? void 0 : target.value;
@@ -1202,7 +1208,7 @@ async function resolveQueryValue(entry, source, ctx, client, defaultValue) {
     self: ctx.selfId ?? null,
     fields: fieldMapFromResolved(ctx.resolvedFields ?? []),
     stage: ctx.stageName ?? null,
-    task: ctx.taskName ?? null,
+    activity: ctx.activityName ?? null,
     now: ctx.now,
     tag: ctx.tag
   });
@@ -1217,38 +1223,47 @@ async function resolveQueryValue(entry, source, ctx, client, defaultValue) {
   }
 }
 async function resolveEntryValue(entry, initialFields, ctx, defaultValue) {
-  const source = entry.source;
-  return source.type === "init" ? resolveInitValue(entry, initialFields, defaultValue) : source.type === "literal" ? source.value ?? defaultValue : source.type === "fieldRead" ? resolveFieldReadValue(source, ctx, defaultValue) : source.type === "query" && ctx.client !== void 0 ? resolveQueryValue(entry, source, ctx, ctx.client, defaultValue) : defaultValue;
+  const source = entry.initialValue;
+  return source === void 0 ? defaultValue : source.type === "input" ? resolveInputValue(entry, initialFields, defaultValue) : source.type === "literal" ? source.value ?? defaultValue : source.type === "fieldRead" ? resolveFieldReadValue(source, ctx, defaultValue) : source.type === "query" && ctx.client !== void 0 ? resolveQueryValue(entry, source, ctx, ctx.client, defaultValue) : defaultValue;
 }
 function buildResolvedEntry(entry, value, _key, now) {
-  const titleProp = entry.title !== void 0 ? { title: entry.title } : {}, descriptionProp = entry.description !== void 0 ? { description: entry.description } : {};
-  return entry.type === "query" ? {
-    _key,
-    _type: "query",
-    name: entry.name,
-    ...titleProp,
-    ...descriptionProp,
-    value,
-    resolvedAt: now
-  } : {
+  return {
     _key,
     _type: entry.type,
     name: entry.name,
-    ...titleProp,
-    ...descriptionProp,
-    value
+    ...entry.title !== void 0 ? { title: entry.title } : {},
+    ...entry.description !== void 0 ? { description: entry.description } : {},
+    value,
+    ...entry.initialValue?.type === "query" ? { resolvedAt: now } : {},
+    ...entry.type === "object" ? { fields: entry.fields ?? [] } : {},
+    ...entry.type === "array" ? { of: entry.of ?? [] } : {}
   };
 }
 async function resolveOneEntry(entry, initialFields, ctx, randomKey2) {
   const defaultValue = defaultEntryValue(entry.type), value = await resolveEntryValue(entry, initialFields, ctx, defaultValue);
-  return validateFieldValue({ entryType: entry.type, entryName: entry.name, value }), buildResolvedEntry(entry, value, randomKey2(), ctx.now);
+  if (entry.initialValue?.type === "query") {
+    const issues = checkFieldValue({
+      entryType: entry.type,
+      value,
+      fields: entry.fields,
+      of: entry.of
+    });
+    return issues !== void 0 ? (ctx.recordDiscard?.({ field: entry.name, detail: issues.join("; ") }), buildResolvedEntry(entry, defaultValue, randomKey2(), ctx.now)) : buildResolvedEntry(entry, value, randomKey2(), ctx.now);
+  }
+  return validateFieldValue({
+    entryType: entry.type,
+    entryName: entry.name,
+    value,
+    fields: entry.fields,
+    of: entry.of
+  }), buildResolvedEntry(entry, value, randomKey2(), ctx.now);
 }
 function fieldMapFromResolved(entries) {
   const out = {};
   for (const s of entries) out[s.name] = s.value;
   return out;
 }
-function assertInitValueShape(entry, value) {
+function assertInputValueShape(entry, value) {
   if (entry.type === "doc.ref") {
     assertGdrShape(value, `field entry "${entry.name}" (doc.ref)`);
     return;
@@ -1258,14 +1273,14 @@ function assertInitValueShape(entry, value) {
     const v2 = value;
     if (typeof v2.releaseName != "string" || v2.releaseName.length === 0)
       throw new Error(
-        `Invalid init value for field entry "${entry.name}" (release.ref): \`releaseName\` must be a non-empty string. Got ${JSON.stringify(v2.releaseName)}.`
+        `Invalid input value for field entry "${entry.name}" (release.ref): \`releaseName\` must be a non-empty string. Got ${JSON.stringify(v2.releaseName)}.`
       );
     return;
   }
   if (entry.type === "doc.refs") {
     if (!Array.isArray(value))
       throw new Error(
-        `Invalid init value for field entry "${entry.name}" (doc.refs): expected an array of GDRs, got ${typeof value}.`
+        `Invalid input value for field entry "${entry.name}" (doc.refs): expected an array of GDRs, got ${typeof value}.`
       );
     for (const [i, item] of value.entries())
       assertGdrShape(item, `field entry "${entry.name}" (doc.refs) item [${i}]`);
@@ -1329,12 +1344,12 @@ async function loadContext(client, instanceId, options) {
 async function ctxConditionParams(ctx, opts) {
   const base = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), fields = {
     ...base.fields,
-    ...scopedFieldOverlay(ctx.instance, ctx.snapshot, opts?.taskName)
+    ...scopedFieldOverlay(ctx.instance, ctx.snapshot, opts?.activityName)
   }, params = {
     ...base,
     fields,
     actor: opts?.actor,
-    assigned: opts?.taskName !== void 0 ? assignedFor(ctx.instance, opts.taskName, opts?.actor, ctx.definition.roleAliases) : !1,
+    assigned: opts?.activityName !== void 0 ? assignedFor(ctx.instance, opts.activityName, opts?.actor, ctx.definition.roleAliases) : !1,
     ...opts?.vars
   };
   return { ...await evaluatePredicates({
@@ -1372,7 +1387,7 @@ function findStage(definition, stageName) {
   return stage;
 }
 async function resolveStageFieldEntries(args) {
-  const { client, instance, stage, now, initialFields } = args;
+  const { client, instance, stage, now, initialFields, recordDiscard } = args;
   return resolveDeclaredFields({
     entryDefs: stage.fields,
     initialFields: initialFields ?? [],
@@ -1383,18 +1398,19 @@ async function resolveStageFieldEntries(args) {
       tag: instance.tag,
       stageName: stage.name,
       workflowResource: instance.workflowResource,
-      // Allow stage-scope entries' `source: { type: "fieldRead", scope:
+      // Allow stage-scope entries' `initialValue: { type: "fieldRead", scope:
       // "workflow", ... }` to see the already-resolved workflow-scope fields.
       workflowFields: instance.fields ?? [],
-      ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
+      ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {},
+      ...recordDiscard !== void 0 ? { recordDiscard } : {}
     },
     randomKey
   });
 }
-async function resolveTaskFieldEntries(args) {
-  const { client, instance, stage, task, now } = args;
+async function resolveActivityFieldEntries(args) {
+  const { client, instance, stage, activity, now, recordDiscard } = args;
   return resolveDeclaredFields({
-    entryDefs: task.fields,
+    entryDefs: activity.fields,
     initialFields: [],
     ctx: {
       client,
@@ -1403,85 +1419,70 @@ async function resolveTaskFieldEntries(args) {
       tag: instance.tag,
       stageName: stage.name,
       workflowResource: instance.workflowResource,
-      taskName: task.name,
+      activityName: activity.name,
       workflowFields: instance.fields ?? [],
-      ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
+      ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {},
+      ...recordDiscard !== void 0 ? { recordDiscard } : {}
     },
     randomKey
   });
 }
-async function deployOrRollback(args) {
-  try {
-    await args.deploy();
-  } catch (guardError) {
-    if (!args.reversible)
-      throw new WorkflowStateDivergedError({
-        instanceId: args.instanceId,
-        guardError,
-        reason: "the move created child instances a parent-only rollback cannot undo"
-      });
-    try {
-      let patch = args.client.patch(args.instanceId).set(args.restore);
-      args.unset && args.unset.length > 0 && (patch = patch.unset(args.unset)), args.committedRev !== void 0 && (patch = patch.ifRevisionId(args.committedRev)), await patch.commit(SYNC_COMMIT);
-    } catch (rollbackError) {
-      throw new WorkflowStateDivergedError({
-        instanceId: args.instanceId,
-        guardError,
-        rollbackError,
-        reason: "rollback of the committed move failed"
-      });
-    }
-    throw guardError instanceof PartialGuardDeployError ? new WorkflowStateDivergedError({
-      instanceId: args.instanceId,
-      guardError,
-      reason: "a multi-guard deploy partially applied; the rolled-back move left orphaned guard locks"
-    }) : guardError;
-  }
+async function resolveBindings(args) {
+  const resolved = {};
+  for (const [key, groq] of Object.entries(args.bindings ?? {}))
+    resolved[key] = await runGroq(groq, args.params, args.snapshot);
+  return { ...resolved, ...args.staticInput };
 }
-function applyTaskStatusChange(args) {
-  const { entry, history, stage, to, at, actor } = args, from = entry.status;
-  entry.status = to, schema.isTerminalTaskStatus(to) && (entry.completedAt = at, actor !== void 0 && (entry.completedBy = actor.id)), history.push({
-    _key: randomKey(),
-    _type: "taskStatusChanged",
-    at,
-    stage,
-    task: entry.name,
-    from,
-    to,
-    ...actor !== void 0 ? { actor } : {}
-  });
+async function reload(client, instanceId, tag) {
+  const doc = await client.getDocument(instanceId);
+  if (!doc)
+    throw new Error(`Workflow instance ${instanceId} not found`);
+  if (doc.tag !== tag)
+    throw new Error(`Workflow instance ${instanceId} not visible to this engine (tag mismatch)`);
+  return doc;
 }
-function stageTransitionHistory(args) {
-  const { fromStage, toStage, at, transition, actor, via, reason } = args, shared = {
-    at,
-    ...transition !== void 0 ? { transition } : {},
-    ...actor !== void 0 ? { actor } : {},
-    ...via !== void 0 ? { via } : {},
-    ...reason !== void 0 ? { reason } : {}
+function effectsContextEntry(name, value) {
+  const _key = randomKey();
+  return typeof value == "string" ? { _key, _type: "effectsContext.string", name, value } : typeof value == "number" ? { _key, _type: "effectsContext.number", name, value } : typeof value == "boolean" ? { _key, _type: "effectsContext.boolean", name, value } : { _key, _type: "effectsContext.ref", name, value };
+}
+function effectsContextJsonEntry(name, value) {
+  return { _key: randomKey(), _type: "effectsContext.json", name, value: JSON.stringify(value) };
+}
+function buildInstanceBase(args) {
+  const { id, now, actor, perspective } = args;
+  return {
+    _id: id,
+    _type: WORKFLOW_INSTANCE_TYPE,
+    _rev: "",
+    _createdAt: now,
+    _updatedAt: now,
+    tag: args.tag,
+    workflowResource: args.workflowResource,
+    definition: args.definitionName,
+    pinnedVersion: args.pinnedVersion,
+    ...args.pinnedContentHash !== void 0 ? { pinnedContentHash: args.pinnedContentHash } : {},
+    definitionSnapshot: JSON.stringify(args.definition),
+    fields: args.fields,
+    effectsContext: args.effectsContext,
+    ancestors: args.ancestors,
+    ...perspective !== void 0 ? { perspective } : {},
+    currentStage: args.initialStage,
+    stages: [],
+    pendingEffects: [],
+    effectHistory: [],
+    history: [
+      {
+        _key: randomKey(),
+        _type: "stageEntered",
+        at: now,
+        stage: args.initialStage,
+        ...actor !== void 0 ? { actor } : {}
+      },
+      ...args.extraHistory ?? []
+    ],
+    startedAt: now,
+    lastChangedAt: now
   };
-  return [
-    {
-      _key: randomKey(),
-      _type: "stageExited",
-      stage: fromStage,
-      toStage,
-      ...shared
-    },
-    {
-      _key: randomKey(),
-      _type: "transitionFired",
-      fromStage,
-      toStage,
-      ...shared
-    },
-    {
-      _key: randomKey(),
-      _type: "stageEntered",
-      stage: toStage,
-      fromStage,
-      ...shared
-    }
-  ];
 }
 function startMutation(instance) {
   return {
@@ -1492,7 +1493,7 @@ function startMutation(instance) {
     stages: instance.stages.map((s) => ({
       ...s,
       fields: (s.fields ?? []).map((entry) => ({ ...entry })),
-      tasks: s.tasks.map((t) => ({
+      activities: s.activities.map((t) => ({
         ...t,
         ...t.fields !== void 0 ? { fields: t.fields.map((entry) => ({ ...entry })) } : {}
       }))
@@ -1568,344 +1569,97 @@ function currentStageEntry(mutation) {
     );
   return entry;
 }
-function currentTasks(mutation) {
-  return currentStageEntry(mutation).tasks;
+function currentActivities(mutation) {
+  return currentStageEntry(mutation).activities;
 }
-function findTaskInCurrentStage(ctx, taskName) {
-  const stage = findStage(ctx.definition, ctx.instance.currentStage), task = (stage.tasks ?? []).find((t) => t.name === taskName);
-  if (task === void 0)
+function findActivityInCurrentStage(ctx, activityName) {
+  const stage = findStage(ctx.definition, ctx.instance.currentStage), activity = (stage.activities ?? []).find((t) => t.name === activityName);
+  if (activity === void 0)
     throw new Error(
-      `Task "${taskName}" not found in current stage "${stage.name}" of ${ctx.definition.name}`
+      `Activity "${activityName}" not found in current stage "${stage.name}" of ${ctx.definition.name}`
     );
-  return { stage, task };
+  return { stage, activity };
 }
-function requireMutationTaskEntry(mutation, task) {
-  const mutEntry = currentTasks(mutation).find((t) => t.name === task);
+function requireMutationActivityEntry(mutation, activity) {
+  const mutEntry = currentActivities(mutation).find((t) => t.name === activity);
   if (mutEntry === void 0)
-    throw new Error(`Task "${task}" disappeared from mutation copy \u2014 invariant broken`);
+    throw new Error(`Activity "${activity}" disappeared from mutation copy \u2014 invariant broken`);
   return mutEntry;
 }
 function findCurrentStageEntry(instance) {
   return findOpenStageEntry(instance);
 }
-function findCurrentTasks(instance) {
-  return findCurrentStageEntry(instance)?.tasks ?? [];
-}
-const TAG_RE = /^[a-z0-9][a-z0-9-]*$/;
-function validateTag(tag) {
-  if (!TAG_RE.test(tag))
-    throw new Error(
-      `tag: invalid tag "${tag}" \u2014 must match ${TAG_RE.source} (ASCII lowercase + digits + dashes, no leading dash, no dots)`
-    );
-}
-function tagScopeFilter() {
-  return "tag == $tag";
-}
-function definitionLookupGroq(explicit) {
-  const scoped = `_type == "${schema.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${tagScopeFilter()}`;
-  return explicit ? `*[${scoped} && version == $version][0]` : `*[${scoped}] | order(version desc)[0]`;
-}
-async function discoverItems(args) {
-  const { client, groq, params, perspective } = args, fetchOptions = perspective !== void 0 ? { perspective } : void 0;
-  return client.fetch(groq, paramsForLake(params), fetchOptions);
+function findCurrentActivities(instance) {
+  return findCurrentStageEntry(instance)?.activities ?? [];
 }
-function clientForDiscovery(defaultClient, clientForGdr, subjectGdrUri) {
-  if (!subjectGdrUri || !subjectGdrUri.includes(":")) return defaultClient;
+async function deployOrRollback(args) {
   try {
-    return clientForGdr(parseGdr(subjectGdrUri));
-  } catch {
-    return defaultClient;
+    await args.deploy();
+  } catch (guardError) {
+    if (!args.reversible)
+      throw new WorkflowStateDivergedError({
+        instanceId: args.instanceId,
+        guardError,
+        reason: "the move created child instances a parent-only rollback cannot undo"
+      });
+    try {
+      let patch = args.client.patch(args.instanceId).set(args.restore);
+      args.unset && args.unset.length > 0 && (patch = patch.unset(args.unset)), args.committedRev !== void 0 && (patch = patch.ifRevisionId(args.committedRev)), await patch.commit(SYNC_COMMIT);
+    } catch (rollbackError) {
+      throw new WorkflowStateDivergedError({
+        instanceId: args.instanceId,
+        guardError,
+        rollbackError,
+        reason: "rollback of the committed move failed"
+      });
+    }
+    throw guardError instanceof PartialGuardDeployError ? new WorkflowStateDivergedError({
+      instanceId: args.instanceId,
+      guardError,
+      reason: "a multi-guard deploy partially applied; the rolled-back move left orphaned guard locks"
+    }) : guardError;
   }
 }
-async function reload(client, instanceId, tag) {
-  const doc = await client.getDocument(instanceId);
-  if (!doc)
-    throw new Error(`Workflow instance ${instanceId} not found`);
-  if (doc.tag !== tag)
-    throw new Error(`Workflow instance ${instanceId} not visible to this engine (tag mismatch)`);
-  return doc;
+async function persistThenDeploy(ctx, mutation, deploy) {
+  const spawned = mutation.pendingCreates.length > 0, committed = await persist(ctx, mutation);
+  await deployOrRollback({
+    client: ctx.client,
+    instanceId: ctx.instance._id,
+    committedRev: committed._rev,
+    restore: instanceStateFields(ctx.instance),
+    unset: ctx.instance.completedAt === void 0 ? ["completedAt"] : [],
+    reversible: !spawned,
+    deploy
+  });
 }
-function effectsContextEntry(name, value) {
-  const _key = randomKey();
-  return typeof value == "string" ? { _key, _type: "effectsContext.string", name, value } : typeof value == "number" ? { _key, _type: "effectsContext.number", name, value } : typeof value == "boolean" ? { _key, _type: "effectsContext.boolean", name, value } : { _key, _type: "effectsContext.ref", name, value };
+async function refreshStageGuards(ctx, mutation, stageName) {
+  await deployStageGuards({
+    client: ctx.client,
+    clientForGdr: ctx.clientForGdr,
+    instance: materializeInstance(ctx.instance, mutation),
+    definition: ctx.definition,
+    stageName,
+    now: ctx.now
+  });
 }
-function effectsContextJsonEntry(name, value) {
-  return { _key: randomKey(), _type: "effectsContext.json", name, value: JSON.stringify(value) };
+async function completeEffect(args) {
+  const { client, instanceId, effectKey, status, outputs, detail, error, durationMs, options } = args, ctx = await loadContext(client, instanceId, {
+    ...options?.clock ? { clock: options.clock } : {},
+    ...options?.clientForGdr ? { clientForGdr: options.clientForGdr } : {}
+  });
+  return commitCompleteEffect(
+    ctx,
+    effectKey,
+    status,
+    outputs,
+    detail,
+    error,
+    durationMs,
+    options?.actor
+  );
 }
-function buildInstanceBase(args) {
-  const { id, now, actor, perspective } = args;
-  return {
-    _id: id,
-    _type: WORKFLOW_INSTANCE_TYPE,
-    _rev: "",
-    _createdAt: now,
-    _updatedAt: now,
-    tag: args.tag,
-    workflowResource: args.workflowResource,
-    definition: args.definitionName,
-    pinnedVersion: args.pinnedVersion,
-    definitionSnapshot: JSON.stringify(args.definition),
-    fields: args.fields,
-    effectsContext: args.effectsContext,
-    ancestors: args.ancestors,
-    ...perspective !== void 0 ? { perspective } : {},
-    currentStage: args.initialStage,
-    stages: [],
-    pendingEffects: [],
-    effectHistory: [],
-    history: [
-      {
-        _key: randomKey(),
-        _type: "stageEntered",
-        at: now,
-        stage: args.initialStage,
-        ...actor !== void 0 ? { actor } : {}
-      }
-    ],
-    startedAt: now,
-    lastChangedAt: now
-  };
-}
-const MAX_SPAWN_DEPTH = 6, SUBWORKFLOWS_ALL_DONE = "count($subworkflows[status != 'done']) == 0", FAIL_WHEN_SYSTEM_ID = "engine.failWhen", COMPLETE_WHEN_SYSTEM_ID = "engine.completeWhen";
-function gateActor(outcome) {
-  return {
-    kind: "system",
-    id: outcome === "failed" ? FAIL_WHEN_SYSTEM_ID : COMPLETE_WHEN_SYSTEM_ID
-  };
-}
-function effectiveCompleteWhen(task) {
-  return task.completeWhen ?? (task.subworkflows !== void 0 ? SUBWORKFLOWS_ALL_DONE : void 0);
-}
-async function evaluateResolutionGate(ctx, task, vars) {
-  const scope = { taskName: task.name, vars };
-  if (task.failWhen !== void 0 && await ctxEvaluateCondition(ctx, task.failWhen, scope))
-    return "failed";
-  const completeWhen = effectiveCompleteWhen(task);
-  if (completeWhen !== void 0 && await ctxEvaluateCondition(ctx, completeWhen, scope))
-    return "done";
-}
-async function spawnSubworkflows(ctx, mutation, task, sub, actor) {
-  if (ctx.instance.ancestors.length + 1 > MAX_SPAWN_DEPTH) {
-    const chain = [...ctx.instance.ancestors.map((a) => a.id), selfGdr(ctx.instance)].join(" \u2192 ");
-    throw new Error(
-      `Subworkflow depth limit (${MAX_SPAWN_DEPTH}) exceeded on task "${task.name}" of ${ctx.instance._id}. Ancestor chain: ${chain}`
-    );
-  }
-  const now = ctx.now, definition = await resolveDefinitionRef(ctx.client, sub.definition, ctx.instance.tag);
-  if (definition === null) {
-    const versionLabel = sub.definition.version === void 0 || sub.definition.version === "latest" ? "latest" : `v${sub.definition.version}`;
-    throw new Error(
-      `Subworkflow definition "${sub.definition.name}" ${versionLabel} not deployed (parent ${ctx.instance._id}, task ${task.name})`
-    );
-  }
-  const parentScope = await ctxConditionParams(ctx, {
-    taskName: task.name,
-    ...actor ? { actor } : {}
-  }), { rows, discoveryResource } = await resolveSpawnRows(ctx, sub), effectsContext = await resolveContextHandoff(ctx, sub, parentScope), refs = [];
-  for (const row of rows) {
-    const initialFields = await projectRowFields(
-      ctx,
-      sub,
-      definition,
-      parentScope,
-      row,
-      discoveryResource
-    ), { ref, body } = await prepareChildInstance({
-      client: ctx.client,
-      parent: ctx.instance,
-      definition,
-      initialFields,
-      effectsContext,
-      actor,
-      now
-    });
-    refs.push(ref), mutation.pendingCreates.push(body);
-  }
-  return refs;
-}
-async function resolveSpawnRows(ctx, sub) {
-  const params = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), groq = sub.forEach;
-  let value, discoveryResource;
-  if (groq.includes("*")) {
-    const routingUri = entrySubjectRefs(ctx.instance.fields)[0]?.id, client = clientForDiscovery(ctx.client, ctx.clientForGdr, routingUri);
-    client !== ctx.client && routingUri !== void 0 && (discoveryResource = resourceFromGdrUri(routingUri)), value = await discoverItems({
-      client,
-      groq,
-      params,
-      // Draft-aware by default (drafts overlay published) when there's no
-      // release, so a `forEach` discovers in-flight items the same way the
-      // engine reads any other content.
-      perspective: ctx.instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE
-    });
-  } else {
-    const tree = groqJs.parse(groq, { params });
-    value = await (await groqJs.evaluate(tree, { dataset: [ctx.instance], params, root: ctx.instance })).get();
-  }
-  return Array.isArray(value) ? { rows: value, discoveryResource } : value == null ? { rows: [], discoveryResource } : { rows: [value], discoveryResource };
-}
-async function projectRowFields(ctx, sub, childDefinition, parentScope, row, discoveryResource) {
-  const out = [];
-  for (const [name, groq] of Object.entries(sub.with ?? {})) {
-    const declared = (childDefinition.fields ?? []).find((e) => e.name === name);
-    if (declared === void 0)
-      throw new Error(
-        `subworkflows.with["${name}"]: subworkflow "${childDefinition.name}" declares no field entry "${name}"`
-      );
-    const raw = await runGroq(groq, { ...parentScope, row }, ctx.snapshot), value = canonicaliseSpawnValue(declared.type, raw, {
-      parentResource: ctx.instance.workflowResource,
-      discoveryResource,
-      entryName: name,
-      childName: childDefinition.name
-    });
-    value != null && out.push({
-      type: declared.type,
-      name,
-      value
-    });
-  }
-  return out;
-}
-async function resolveContextHandoff(ctx, sub, parentScope) {
-  const out = {};
-  for (const [name, groq] of Object.entries(sub.context ?? {})) {
-    const v2 = await runGroq(groq, parentScope, ctx.snapshot);
-    v2 != null && (typeof v2 == "string" || typeof v2 == "number" || typeof v2 == "boolean" || typeof v2 == "object" && "id" in v2 && "type" in v2) && (out[name] = v2);
-  }
-  return out;
-}
-function canonicaliseSpawnValue(kind, value, cx) {
-  return kind === "doc.ref" ? coerceSpawnGdr(value, cx) : kind === "doc.refs" && Array.isArray(value) ? value.map((v2) => coerceSpawnGdr(v2, cx)).filter((v2) => v2 !== null) : value;
-}
-function assertBareIdRootsCorrectly(id, cx) {
-  if (!(cx.discoveryResource === void 0 || sameResource(cx.discoveryResource, cx.parentResource)))
-    throw new Error(
-      `subworkflows.with["${cx.entryName}"]: subworkflow "${cx.childName}" projected the bare id "${id}", which roots at the parent resource "${cx.parentResource.id}", but spawn discovery ran against "${cx.discoveryResource.id}". The child would reference a document that doesn't exist in the parent resource. Project an explicit GDR URI in the with-GROQ (e.g. "dataset:<projectId>:<dataset>:" + _id) so the child's subject points at the resource the discovered rows came from.`
-    );
-}
-function coerceSpawnGdr(raw, cx) {
-  const toUri = (id) => isGdrUri(id) ? id : (assertBareIdRootsCorrectly(id, cx), gdrFromResource(cx.parentResource, id));
-  if (raw == null) return null;
-  if (typeof raw == "object" && "id" in raw && "type" in raw) {
-    const r = raw;
-    if (typeof r.id == "string" && typeof r.type == "string")
-      return { id: toUri(r.id), type: r.type };
-  }
-  if (typeof raw == "object" && "_ref" in raw) {
-    const r = raw;
-    if (typeof r._ref == "string") return { id: toUri(r._ref), type: "document" };
-  }
-  return typeof raw == "string" && raw.length > 0 ? { id: toUri(raw), type: "document" } : null;
-}
-async function resolveDefinitionRef(client, ref, tag) {
-  const wantsExplicit = typeof ref.version == "number", params = { definition: ref.name, tag };
-  return wantsExplicit && (params.version = ref.version), await client.fetch(
-    definitionLookupGroq(wantsExplicit),
-    params
-  ) ?? null;
-}
-async function prepareChildInstance(args) {
-  const { client, parent, definition, initialFields, effectsContext, actor, now } = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = `${childTag}.wf-instance.${randomKey()}`, childRef = { id: gdrFromResource(workflowResource, childDocId), type: WORKFLOW_INSTANCE_TYPE }, ancestors = [
-    ...parent.ancestors,
-    {
-      id: selfGdr(parent),
-      type: WORKFLOW_INSTANCE_TYPE
-    }
-  ], inheritedPerspective = parent.perspective, childFields = await resolveDeclaredFields({
-    entryDefs: definition.fields,
-    initialFields,
-    ctx: {
-      client,
-      now,
-      selfId: childDocId,
-      tag: childTag,
-      workflowResource,
-      definitionName: definition.name,
-      ...inheritedPerspective !== void 0 ? { perspective: inheritedPerspective } : {}
-    },
-    randomKey
-  }), childPerspective = derivePerspectiveFromFields(childFields) ?? inheritedPerspective, effectsContextEntries = Object.entries(effectsContext).map(
-    ([key, value]) => {
-      if (typeof value == "object" && value !== null && "id" in value && "type" in value) {
-        if (!isGdrUri(value.id))
-          throw new Error(
-            `subworkflows.context["${key}"]: GDR id must be a "<scheme>:..." URI, got ${JSON.stringify(value.id)}.`
-          );
-        return effectsContextEntry(key, { id: value.id, type: value.type });
-      }
-      return effectsContextEntry(key, value);
-    }
-  ), base = buildInstanceBase({
-    id: childDocId,
-    now,
-    tag: childTag,
-    workflowResource,
-    definitionName: definition.name,
-    pinnedVersion: definition.version,
-    definition,
-    fields: childFields,
-    effectsContext: effectsContextEntries,
-    ancestors,
-    perspective: childPerspective,
-    initialStage: definition.initialStage,
-    actor
-  });
-  return { ref: childRef, body: base };
-}
-async function subworkflowRows(ctx, refs) {
-  if (refs.length === 0) return [];
-  const ids = refs.map((r) => gdrToBareId(r.id));
-  return (await ctx.client.fetch("*[_id in $ids]{_id, currentStage, completedAt}", { ids })).map((c) => ({
-    _id: c._id,
-    stage: c.currentStage,
-    status: c.completedAt !== void 0 && c.completedAt !== null ? "done" : "active"
-  }));
-}
-async function resolveBindings(args) {
-  const resolved = {};
-  for (const [key, groq] of Object.entries(args.bindings ?? {}))
-    resolved[key] = await runGroq(groq, args.params, args.snapshot);
-  return { ...resolved, ...args.staticInput };
-}
-async function persistThenDeploy(ctx, mutation, deploy) {
-  const spawned = mutation.pendingCreates.length > 0, committed = await persist(ctx, mutation);
-  await deployOrRollback({
-    client: ctx.client,
-    instanceId: ctx.instance._id,
-    committedRev: committed._rev,
-    restore: instanceStateFields(ctx.instance),
-    unset: ctx.instance.completedAt === void 0 ? ["completedAt"] : [],
-    reversible: !spawned,
-    deploy
-  });
-}
-async function refreshStageGuards(ctx, mutation, stageName) {
-  await deployStageGuards({
-    client: ctx.client,
-    clientForGdr: ctx.clientForGdr,
-    instance: materializeInstance(ctx.instance, mutation),
-    definition: ctx.definition,
-    stageName,
-    now: ctx.now
-  });
-}
-async function completeEffect(args) {
-  const { client, instanceId, effectKey, status, outputs, detail, error, durationMs, options } = args, ctx = await loadContext(client, instanceId, {
-    ...options?.clock ? { clock: options.clock } : {},
-    ...options?.clientForGdr ? { clientForGdr: options.clientForGdr } : {}
-  });
-  return commitCompleteEffect(
-    ctx,
-    effectKey,
-    status,
-    outputs,
-    detail,
-    error,
-    durationMs,
-    options?.actor
-  );
-}
-function buildEffectHistoryEntry(pending, outcome) {
-  const { status, ranAt, actor, detail, error, durationMs, outputs } = outcome, resolvedActor = actor ?? pending.actor;
+function buildEffectHistoryEntry(pending, outcome) {
+  const { status, ranAt, actor, detail, error, durationMs, outputs } = outcome, resolvedActor = actor ?? pending.actor;
   return {
     _key: pending._key,
     name: pending.name,
@@ -1978,7 +1732,7 @@ function buildQueuedEffect(effect, origin, params, actor, now) {
 async function queueEffects(ctx, mutation, effects, origin, actor, opts) {
   if (!effects || effects.length === 0) return;
   const now = ctx.now, liveCtx = { ...ctx, instance: materializeInstance(ctx.instance, mutation) }, params = await ctxConditionParams(liveCtx, {
-    ...opts?.taskName !== void 0 ? { taskName: opts.taskName } : {},
+    ...opts?.activityName !== void 0 ? { activityName: opts.activityName } : {},
     ...actor !== void 0 ? { actor } : {},
     // Caller-supplied action params, readable in bindings as `$params.<name>`.
     vars: { params: opts?.callerParams ?? {} }
@@ -1993,18 +1747,74 @@ async function queueEffects(ctx, mutation, effects, origin, actor, opts) {
     mutation.pendingEffects.push(pending), mutation.history.push(history);
   }
 }
-function resolveStaticSource(src, ctx) {
+function fieldQueryDiscardedEntry(args) {
+  return {
+    _key: randomKey(),
+    _type: "fieldQueryDiscarded",
+    at: args.at,
+    scope: args.scope,
+    field: args.field,
+    detail: args.detail
+  };
+}
+function recordFieldDiscards(target, scope, at) {
+  return (discard) => target.push(fieldQueryDiscardedEntry({ scope, field: discard.field, detail: discard.detail, at }));
+}
+function applyActivityStatusChange(args) {
+  const { entry, history, stage, to, at, actor } = args, from = entry.status;
+  entry.status = to, schema.isTerminalActivityStatus(to) && (entry.completedAt = at, actor !== void 0 && (entry.completedBy = actor.id)), history.push({
+    _key: randomKey(),
+    _type: "activityStatusChanged",
+    at,
+    stage,
+    activity: entry.name,
+    from,
+    to,
+    ...actor !== void 0 ? { actor } : {}
+  });
+}
+function stageTransitionHistory(args) {
+  const { fromStage, toStage, at, transition, actor, via, reason } = args, shared = {
+    at,
+    ...transition !== void 0 ? { transition } : {},
+    ...actor !== void 0 ? { actor } : {},
+    ...via !== void 0 ? { via } : {},
+    ...reason !== void 0 ? { reason } : {}
+  };
+  return [
+    {
+      _key: randomKey(),
+      _type: "stageExited",
+      stage: fromStage,
+      toStage,
+      ...shared
+    },
+    {
+      _key: randomKey(),
+      _type: "transitionFired",
+      fromStage,
+      toStage,
+      ...shared
+    },
+    {
+      _key: randomKey(),
+      _type: "stageEntered",
+      stage: toStage,
+      fromStage,
+      ...shared
+    }
+  ];
+}
+function resolveStaticValueExpr(src, ctx) {
   switch (src.type) {
     case "literal":
-      return { handled: !0, value: src.value };
+      return src.value;
     case "param":
-      return { handled: !0, value: ctx.params?.[src.param] };
+      return ctx.params?.[src.param];
     case "actor":
-      return { handled: !0, value: ctx.actor };
+      return ctx.actor;
     case "now":
-      return { handled: !0, value: ctx.now };
-    default:
-      return { handled: !1 };
+      return ctx.now;
   }
 }
 const FIELD_OP_TYPES = [
@@ -2017,7 +1827,7 @@ const FIELD_OP_TYPES = [
 function isFieldOp(summary) {
   return FIELD_OP_TYPES.includes(summary.opType);
 }
-function validateActionParams(action, taskName, callerParams) {
+function validateActionParams(action, activityName, callerParams) {
   const declared = action.params ?? [], params = callerParams ?? {}, issues = [];
   for (const decl of declared) {
     const value = params[decl.name], present = decl.name in params && value !== void 0 && value !== null;
@@ -2031,7 +1841,7 @@ function validateActionParams(action, taskName, callerParams) {
     }));
   }
   if (issues.length > 0)
-    throw new ActionParamsInvalidError({ action: action.name, task: taskName, issues });
+    throw new ActionParamsInvalidError({ action: action.name, activity: activityName, issues });
   return params;
 }
 function hasStringField(value, field) {
@@ -2064,7 +1874,15 @@ function runOps(args) {
   if (ops === void 0 || ops.length === 0) return [];
   const summaries = [];
   for (const op of ops) {
-    const summary = applyOp(op, { mutation, stage, taskName: origin.task, params, actor, self, now });
+    const summary = applyOp(op, {
+      mutation,
+      stage,
+      activityName: origin.activity,
+      params,
+      actor,
+      self,
+      now
+    });
     summaries.push(summary), mutation.history.push(opAppliedEntry({ origin, summary, stage, actor, now }));
   }
   return summaries;
@@ -2076,7 +1894,7 @@ function opAppliedEntry(args) {
     _type: "opApplied",
     at: now,
     stage,
-    ...origin.task !== void 0 ? { task: origin.task } : {},
+    ...origin.activity !== void 0 ? { activity: origin.activity } : {},
     ...origin.action !== void 0 ? { action: origin.action } : {},
     ...origin.transition !== void 0 ? { transition: origin.transition } : {},
     ...origin.edit === !0 ? { edit: !0 } : {},
@@ -2103,13 +1921,15 @@ function applyOp(op, ctx) {
   }
 }
 function applyFieldSet(op, ctx) {
-  const value = resolveOpSource(op.value, ctx), entry = locateEntry(ctx, op.target);
-  return validateFieldValue({ entryType: entry._type, entryName: entry.name, value }), setEntryValue(entry, value), { opType: op.type, target: op.target, resolved: { value } };
+  const value = resolveOpValue(op.value, ctx), entry = locateEntry(ctx, op.target);
+  return validateFieldValue({ entryType: entry._type, entryName: entry.name, value, ...entryShape(entry) }), setEntryValue(entry, value), { opType: op.type, target: op.target, resolved: { value } };
+}
+function entryShape(entry) {
+  return entry._type === "object" ? { fields: entry.fields } : entry._type === "array" ? { of: entry.of } : {};
 }
 const EMPTY_BY_KIND = {
   "doc.refs": [],
-  checklist: [],
-  notes: [],
+  array: [],
   assignees: []
 };
 function applyFieldUnset(op, ctx) {
@@ -2117,8 +1937,13 @@ function applyFieldUnset(op, ctx) {
   return setEntryValue(entry, EMPTY_BY_KIND[entry._type] ?? null), { opType: op.type, target: op.target };
 }
 function applyFieldAppend(op, ctx) {
-  const item = resolveOpSource(op.value, ctx), entry = locateEntry(ctx, op.target);
-  validateFieldAppendItem({ entryType: entry._type, entryName: entry.name, item });
+  const item = resolveOpValue(op.value, ctx), entry = locateEntry(ctx, op.target);
+  validateFieldAppendItem({
+    entryType: entry._type,
+    entryName: entry.name,
+    item,
+    of: entry._type === "array" ? entry.of : void 0
+  });
   const current = Array.isArray(entry.value) ? entry.value : [];
   return setEntryValue(entry, [...current, withRowKey(item)]), { opType: op.type, target: op.target, resolved: { item } };
 }
@@ -2126,7 +1951,7 @@ function withRowKey(item) {
   return typeof item == "object" && item !== null && !Array.isArray(item) && !("_key" in item) ? { _key: randomKey(), ...item } : item;
 }
 function applyFieldUpdateWhere(op, ctx) {
-  const entry = locateEntry(ctx, op.target), rows = requireArrayValue(entry, op), merge = resolveOpSource(op.value, ctx);
+  const entry = locateEntry(ctx, op.target), rows = requireArrayValue(entry, op), merge = resolveOpValue(op.value, ctx);
   if (merge === null || typeof merge != "object" || Array.isArray(merge))
     throw new Error(
       `field.updateWhere value must resolve to an object of fields to merge (target "${op.target.field}")`
@@ -2152,145 +1977,385 @@ function requireArrayValue(entry, op) {
     );
   return entry.value;
 }
-function applyStatusSet(op, ctx) {
-  const entry = findOpenStageEntry(ctx.mutation)?.tasks.find((t) => t.name === op.task);
-  if (entry === void 0)
-    throw new Error(`status.set targets task "${op.task}" which has no entry in the open stage`);
-  return applyTaskStatusChange({
-    entry,
-    history: ctx.mutation.history,
-    stage: ctx.stage,
-    to: op.status,
-    at: ctx.now,
-    ...ctx.actor !== void 0 ? { actor: ctx.actor } : {}
-  }), { opType: op.type, resolved: { task: op.task, status: op.status } };
+function applyStatusSet(op, ctx) {
+  const entry = findOpenStageEntry(ctx.mutation)?.activities.find((t) => t.name === op.activity);
+  if (entry === void 0)
+    throw new Error(
+      `status.set targets activity "${op.activity}" which has no entry in the open stage`
+    );
+  return applyActivityStatusChange({
+    entry,
+    history: ctx.mutation.history,
+    stage: ctx.stage,
+    to: op.status,
+    at: ctx.now,
+    ...ctx.actor !== void 0 ? { actor: ctx.actor } : {}
+  }), { opType: op.type, resolved: { activity: op.activity, status: op.status } };
+}
+function setEntryValue(entry, value) {
+  entry.value = value;
+}
+function locateEntry(ctx, target) {
+  const entry = fieldHost(ctx, target.scope)?.find((s) => s.name === target.field);
+  if (entry === void 0)
+    throw new Error(
+      `Op target ${target.scope}:"${target.field}" has no resolved field entry on this instance \u2014 the deployed definition and the instance state have diverged`
+    );
+  return entry;
+}
+function fieldHost(ctx, scope) {
+  if (scope === "workflow") return ctx.mutation.fields;
+  const stageEntry = findOpenStageEntry(ctx.mutation);
+  if (scope === "stage") return stageEntry?.fields;
+  const activity = stageEntry?.activities.find((t) => t.name === ctx.activityName);
+  return activity !== void 0 && activity.fields === void 0 && (activity.fields = []), activity?.fields;
+}
+function resolveOpValue(src, ctx) {
+  switch (src.type) {
+    case "literal":
+    case "param":
+    case "actor":
+    case "now":
+      return resolveStaticValueExpr(src, ctx);
+    case "self":
+      return ctx.self;
+    case "stage":
+      return ctx.stage;
+    case "fieldRead": {
+      const value = readEntryFromMutation(ctx, src);
+      return src.path !== void 0 ? getPath(value, src.path) : value;
+    }
+    case "object": {
+      const out = {};
+      for (const [field, fieldSrc] of Object.entries(src.fields))
+        out[field] = resolveOpValue(fieldSrc, ctx);
+      return out;
+    }
+  }
+}
+function entryValue(entries, name) {
+  return entries?.find((s) => s.name === name)?.value;
+}
+function readEntryFromMutation(ctx, src) {
+  const scopes = src.scope !== void 0 ? [src.scope] : ["stage", "workflow"], stageEntry = findOpenStageEntry(ctx.mutation);
+  for (const scope of scopes) {
+    const host = scope === "workflow" ? ctx.mutation.fields : stageEntry?.fields, value = entryValue(host, src.field);
+    if (value !== void 0) return value;
+  }
+}
+function evalOpPredicate(p, row, ctx) {
+  switch (p.type) {
+    case "all":
+      return p.of.every((sub) => evalOpPredicate(sub, row, ctx));
+    case "any":
+      return p.of.some((sub) => evalOpPredicate(sub, row, ctx));
+    case "field":
+      return row[p.field] === resolveOpValue(p.equals, ctx);
+  }
+}
+const TAG_RE = /^[a-z0-9][a-z0-9-]*$/;
+function validateTag(tag) {
+  if (!TAG_RE.test(tag))
+    throw new Error(
+      `tag: invalid tag "${tag}" \u2014 must match ${TAG_RE.source} (ASCII lowercase + digits + dashes, no leading dash, no dots)`
+    );
+}
+function tagScopeFilter() {
+  return "tag == $tag";
+}
+function definitionLookupGroq(explicit) {
+  const scoped = `_type == "${schema.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${tagScopeFilter()}`;
+  return explicit ? `*[${scoped} && version == $version][0]` : `*[${scoped}] | order(version desc)[0]`;
+}
+async function discoverItems(args) {
+  const { client, groq, params, perspective } = args, fetchOptions = perspective !== void 0 ? { perspective } : void 0;
+  return client.fetch(groq, paramsForLake(params), fetchOptions);
+}
+function clientForDiscovery(defaultClient, clientForGdr, subjectGdrUri) {
+  if (!subjectGdrUri || !subjectGdrUri.includes(":")) return defaultClient;
+  try {
+    return clientForGdr(parseGdr(subjectGdrUri));
+  } catch {
+    return defaultClient;
+  }
+}
+const ENGINE_ACTOR_ID_PREFIX = "engine.";
+function engineSystemActor(name) {
+  return { kind: "system", id: `${ENGINE_ACTOR_ID_PREFIX}${name}` };
+}
+function isEngineActor(actor) {
+  return actor.kind === "system" && actor.id.startsWith(ENGINE_ACTOR_ID_PREFIX);
+}
+const MAX_SPAWN_DEPTH = 6, SUBWORKFLOWS_ALL_DONE = "count($subworkflows[status != 'done']) == 0";
+function gateActor(outcome) {
+  return engineSystemActor(outcome === "failed" ? "failWhen" : "completeWhen");
+}
+function effectiveCompleteWhen(activity) {
+  return activity.completeWhen ?? (activity.subworkflows !== void 0 ? SUBWORKFLOWS_ALL_DONE : void 0);
+}
+async function evaluateResolutionGate(ctx, activity, vars) {
+  const scope = { activityName: activity.name, vars };
+  if (activity.failWhen !== void 0 && await ctxEvaluateCondition(ctx, activity.failWhen, scope))
+    return "failed";
+  const completeWhen = effectiveCompleteWhen(activity);
+  if (completeWhen !== void 0 && await ctxEvaluateCondition(ctx, completeWhen, scope))
+    return "done";
+}
+async function spawnSubworkflows(ctx, mutation, activity, sub, actor) {
+  if (ctx.instance.ancestors.length + 1 > MAX_SPAWN_DEPTH) {
+    const chain = [...ctx.instance.ancestors.map((a) => a.id), selfGdr(ctx.instance)].join(" \u2192 ");
+    throw new Error(
+      `Subworkflow depth limit (${MAX_SPAWN_DEPTH}) exceeded on activity "${activity.name}" of ${ctx.instance._id}. Ancestor chain: ${chain}`
+    );
+  }
+  const now = ctx.now, definition = await resolveDefinitionRef(ctx.client, sub.definition, ctx.instance.tag);
+  if (definition === null) {
+    const versionLabel = sub.definition.version === void 0 || sub.definition.version === "latest" ? "latest" : `v${sub.definition.version}`;
+    throw new Error(
+      `Subworkflow definition "${sub.definition.name}" ${versionLabel} not deployed (parent ${ctx.instance._id}, activity ${activity.name})`
+    );
+  }
+  const parentScope = await ctxConditionParams(ctx, {
+    activityName: activity.name,
+    ...actor ? { actor } : {}
+  }), { rows, discoveryResource } = await resolveSpawnRows(ctx, sub), effectsContext = await resolveContextHandoff(ctx, sub, parentScope), refs = [];
+  for (const row of rows) {
+    const initialFields = await projectRowFields(
+      ctx,
+      sub,
+      definition,
+      parentScope,
+      row,
+      discoveryResource
+    ), { ref, body } = await prepareChildInstance({
+      client: ctx.client,
+      parent: ctx.instance,
+      definition,
+      initialFields,
+      effectsContext,
+      actor,
+      now
+    });
+    refs.push(ref), mutation.pendingCreates.push(body);
+  }
+  return refs;
+}
+async function resolveSpawnRows(ctx, sub) {
+  const params = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), groq = sub.forEach;
+  let value, discoveryResource;
+  if (groq.includes("*")) {
+    const routingUri = entrySubjectRefs(ctx.instance.fields)[0]?.id, client = clientForDiscovery(ctx.client, ctx.clientForGdr, routingUri);
+    client !== ctx.client && routingUri !== void 0 && (discoveryResource = resourceFromGdrUri(routingUri)), value = await discoverItems({
+      client,
+      groq,
+      params,
+      // Draft-aware by default (drafts overlay published) when there's no
+      // release, so a `forEach` discovers in-flight items the same way the
+      // engine reads any other content.
+      perspective: ctx.instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE
+    });
+  } else {
+    const tree = groqJs.parse(groq, { params });
+    value = await (await groqJs.evaluate(tree, { dataset: [ctx.instance], params, root: ctx.instance })).get();
+  }
+  return Array.isArray(value) ? { rows: value, discoveryResource } : value == null ? { rows: [], discoveryResource } : { rows: [value], discoveryResource };
+}
+async function projectRowFields(ctx, sub, childDefinition, parentScope, row, discoveryResource) {
+  const out = [];
+  for (const [name, groq] of Object.entries(sub.with ?? {})) {
+    const declared = (childDefinition.fields ?? []).find((e) => e.name === name);
+    if (declared === void 0)
+      throw new Error(
+        `subworkflows.with["${name}"]: subworkflow "${childDefinition.name}" declares no field entry "${name}"`
+      );
+    const raw = await runGroq(groq, { ...parentScope, row }, ctx.snapshot), value = canonicaliseSpawnValue(declared.type, raw, {
+      parentResource: ctx.instance.workflowResource,
+      discoveryResource,
+      entryName: name,
+      childName: childDefinition.name
+    });
+    value != null && out.push({
+      type: declared.type,
+      name,
+      value
+    });
+  }
+  return out;
+}
+async function resolveContextHandoff(ctx, sub, parentScope) {
+  const out = {};
+  for (const [name, groq] of Object.entries(sub.context ?? {})) {
+    const v2 = await runGroq(groq, parentScope, ctx.snapshot);
+    v2 != null && (typeof v2 == "string" || typeof v2 == "number" || typeof v2 == "boolean" || typeof v2 == "object" && "id" in v2 && "type" in v2) && (out[name] = v2);
+  }
+  return out;
 }
-function setEntryValue(entry, value) {
-  entry.value = value;
+function canonicaliseSpawnValue(kind, value, cx) {
+  return kind === "doc.ref" ? coerceSpawnGdr(value, cx) : kind === "doc.refs" && Array.isArray(value) ? value.map((v2) => coerceSpawnGdr(v2, cx)).filter((v2) => v2 !== null) : value;
 }
-function locateEntry(ctx, target) {
-  const entry = fieldHost(ctx, target.scope)?.find((s) => s.name === target.field);
-  if (entry === void 0)
+function assertBareIdRootsCorrectly(id, cx) {
+  if (!(cx.discoveryResource === void 0 || sameResource(cx.discoveryResource, cx.parentResource)))
     throw new Error(
-      `Op target ${target.scope}:"${target.field}" has no resolved field entry on this instance \u2014 the deployed definition and the instance state have diverged`
+      `subworkflows.with["${cx.entryName}"]: subworkflow "${cx.childName}" projected the bare id "${id}", which roots at the parent resource "${cx.parentResource.id}", but spawn discovery ran against "${cx.discoveryResource.id}". The child would reference a document that doesn't exist in the parent resource. Project an explicit GDR URI in the with-GROQ (e.g. "dataset:<projectId>:<dataset>:" + _id) so the child's subject points at the resource the discovered rows came from.`
     );
-  return entry;
 }
-function fieldHost(ctx, scope) {
-  if (scope === "workflow") return ctx.mutation.fields;
-  const stageEntry = findOpenStageEntry(ctx.mutation);
-  if (scope === "stage") return stageEntry?.fields;
-  const task = stageEntry?.tasks.find((t) => t.name === ctx.taskName);
-  return task !== void 0 && task.fields === void 0 && (task.fields = []), task?.fields;
-}
-function resolveOpSource(src, ctx) {
-  const staticValue = resolveStaticSource(src, ctx);
-  if (staticValue.handled) return staticValue.value;
-  switch (src.type) {
-    case "self":
-      return ctx.self;
-    case "stage":
-      return ctx.stage;
-    case "fieldRead": {
-      const value = readEntryFromMutation(ctx, src);
-      return src.path !== void 0 ? getPath(value, src.path) : value;
-    }
-    case "object": {
-      const out = {};
-      for (const [field, fieldSrc] of Object.entries(src.fields))
-        out[field] = resolveOpSource(fieldSrc, ctx);
-      return out;
-    }
-    default:
-      throw new Error(`Source type "${src.type}" is a field-entry origin, not a value`);
+function coerceSpawnGdr(raw, cx) {
+  const toUri = (id) => isGdrUri(id) ? id : (assertBareIdRootsCorrectly(id, cx), gdrFromResource(cx.parentResource, id));
+  if (raw == null) return null;
+  if (typeof raw == "object" && "id" in raw && "type" in raw) {
+    const r = raw;
+    if (typeof r.id == "string" && typeof r.type == "string")
+      return { id: toUri(r.id), type: r.type };
+  }
+  if (typeof raw == "object" && "_ref" in raw) {
+    const r = raw;
+    if (typeof r._ref == "string") return { id: toUri(r._ref), type: "document" };
   }
+  return typeof raw == "string" && raw.length > 0 ? { id: toUri(raw), type: "document" } : null;
 }
-function entryValue(entries, name) {
-  return entries?.find((s) => s.name === name)?.value;
+async function resolveDefinitionRef(client, ref, tag) {
+  const wantsExplicit = typeof ref.version == "number", params = { definition: ref.name, tag };
+  return wantsExplicit && (params.version = ref.version), await client.fetch(
+    definitionLookupGroq(wantsExplicit),
+    params
+  ) ?? null;
 }
-function readEntryFromMutation(ctx, src) {
-  const scopes = src.scope !== void 0 ? [src.scope] : ["stage", "workflow"], stageEntry = findOpenStageEntry(ctx.mutation);
-  for (const scope of scopes) {
-    const host = scope === "workflow" ? ctx.mutation.fields : stageEntry?.fields, value = entryValue(host, src.field);
-    if (value !== void 0) return value;
-  }
+async function prepareChildInstance(args) {
+  const { client, parent, definition, initialFields, effectsContext, actor, now } = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = `${childTag}.wf-instance.${randomKey()}`, childRef = { id: gdrFromResource(workflowResource, childDocId), type: WORKFLOW_INSTANCE_TYPE }, ancestors = [
+    ...parent.ancestors,
+    {
+      id: selfGdr(parent),
+      type: WORKFLOW_INSTANCE_TYPE
+    }
+  ], inheritedPerspective = parent.perspective, fieldDiscards = [], childFields = await resolveDeclaredFields({
+    entryDefs: definition.fields,
+    initialFields,
+    ctx: {
+      client,
+      now,
+      selfId: childDocId,
+      tag: childTag,
+      workflowResource,
+      definitionName: definition.name,
+      ...inheritedPerspective !== void 0 ? { perspective: inheritedPerspective } : {},
+      recordDiscard: recordFieldDiscards(fieldDiscards, "workflow", now)
+    },
+    randomKey
+  }), childPerspective = derivePerspectiveFromFields(childFields) ?? inheritedPerspective, effectsContextEntries = Object.entries(effectsContext).map(
+    ([key, value]) => {
+      if (typeof value == "object" && value !== null && "id" in value && "type" in value) {
+        if (!isGdrUri(value.id))
+          throw new Error(
+            `subworkflows.context["${key}"]: GDR id must be a "<scheme>:..." URI, got ${JSON.stringify(value.id)}.`
+          );
+        return effectsContextEntry(key, { id: value.id, type: value.type });
+      }
+      return effectsContextEntry(key, value);
+    }
+  ), base = buildInstanceBase({
+    id: childDocId,
+    now,
+    tag: childTag,
+    workflowResource,
+    definitionName: definition.name,
+    pinnedVersion: definition.version,
+    pinnedContentHash: definition.contentHash,
+    definition,
+    fields: childFields,
+    effectsContext: effectsContextEntries,
+    ancestors,
+    perspective: childPerspective,
+    initialStage: definition.initialStage,
+    actor,
+    ...fieldDiscards.length > 0 ? { extraHistory: fieldDiscards } : {}
+  });
+  return { ref: childRef, body: base };
 }
-function evalOpPredicate(p, row, ctx) {
-  switch (p.type) {
-    case "all":
-      return p.of.every((sub) => evalOpPredicate(sub, row, ctx));
-    case "any":
-      return p.of.some((sub) => evalOpPredicate(sub, row, ctx));
-    case "field":
-      return row[p.field] === resolveOpSource(p.equals, ctx);
-  }
+async function subworkflowRows(ctx, refs) {
+  if (refs.length === 0) return [];
+  const ids = refs.map((r) => gdrToBareId(r.id));
+  return (await ctx.client.fetch("*[_id in $ids]{_id, currentStage, completedAt}", { ids })).map((c) => ({
+    _id: c._id,
+    stage: c.currentStage,
+    status: c.completedAt !== void 0 && c.completedAt !== null ? "done" : "active"
+  }));
 }
-async function invokeTask(args) {
-  const { client, instanceId, task: taskName, options } = args, ctx = await loadContext(client, instanceId, {
+async function invokeActivity(args) {
+  const { client, instanceId, activity: activityName, options } = args, ctx = await loadContext(client, instanceId, {
     ...options?.clock ? { clock: options.clock } : {},
     ...options?.clientForGdr ? { clientForGdr: options.clientForGdr } : {}
   });
-  return commitInvoke(ctx, taskName, options?.actor);
+  return commitInvoke(ctx, activityName, options?.actor);
 }
-async function commitInvoke(ctx, taskName, actor) {
-  const { task } = findTaskInCurrentStage(ctx, taskName), entry = findCurrentTasks(ctx.instance).find((t) => t.name === taskName);
+async function commitInvoke(ctx, activityName, actor) {
+  const { activity } = findActivityInCurrentStage(ctx, activityName), entry = findCurrentActivities(ctx.instance).find((t) => t.name === activityName);
   if (entry === void 0)
-    throw new Error(`Task "${taskName}" has no status entry on instance ${ctx.instance._id}`);
+    throw new Error(
+      `Activity "${activityName}" has no status entry on instance ${ctx.instance._id}`
+    );
   if (entry.status !== "pending")
-    return { invoked: !1, task: taskName };
-  const mutation = startMutation(ctx.instance), mutEntry = requireMutationTaskEntry(mutation, taskName);
-  return await activateTask(ctx, mutation, task, mutEntry, actor), await persist(ctx, mutation), { invoked: !0, task: taskName };
+    return { invoked: !1, activity: activityName };
+  const mutation = startMutation(ctx.instance), mutEntry = requireMutationActivityEntry(mutation, activityName);
+  return await activateActivity(ctx, mutation, activity, mutEntry, actor), await persist(ctx, mutation), { invoked: !0, activity: activityName };
 }
-async function activateTask(ctx, mutation, task, entry, actor) {
+async function activateActivity(ctx, mutation, activity, entry, actor) {
   const now = ctx.now;
-  if (entry.status = "active", entry.startedAt = now, task.fields !== void 0 && task.fields.length > 0) {
+  if (entry.status = "active", entry.startedAt = now, activity.fields !== void 0 && activity.fields.length > 0) {
     const stage = findStage(ctx.definition, mutation.currentStage);
-    entry.fields = await resolveTaskFieldEntries({
+    entry.fields = await resolveActivityFieldEntries({
       client: ctx.client,
       instance: ctx.instance,
       stage,
-      task,
-      now
+      activity,
+      now,
+      recordDiscard: recordFieldDiscards(mutation.history, "activity", now)
     });
   }
   runOps({
-    ops: task.ops,
+    ops: activity.ops,
     mutation,
     stage: mutation.currentStage,
-    origin: { task: task.name },
+    origin: { activity: activity.name },
     params: {},
     actor,
     self: selfGdr(ctx.instance),
     now
   }), mutation.history.push({
     _key: randomKey(),
-    _type: "taskActivated",
+    _type: "activityActivated",
     at: now,
     stage: mutation.currentStage,
-    task: task.name,
+    activity: activity.name,
     ...actor !== void 0 ? { actor } : {}
-  }), await queueEffects(ctx, mutation, task.effects, { kind: "task", name: task.name }, actor, {
-    taskName: task.name
-  });
+  }), await queueEffects(
+    ctx,
+    mutation,
+    activity.effects,
+    { kind: "activity", name: activity.name },
+    actor,
+    {
+      activityName: activity.name
+    }
+  );
   let pendingChildren;
-  if (task.subworkflows !== void 0) {
-    const createsBefore = mutation.pendingCreates.length, refs = await spawnSubworkflows(ctx, mutation, task, task.subworkflows, actor);
+  if (activity.subworkflows !== void 0) {
+    const createsBefore = mutation.pendingCreates.length, refs = await spawnSubworkflows(ctx, mutation, activity, activity.subworkflows, actor);
     entry.spawnedInstances = refs, pendingChildren = mutation.pendingCreates.slice(createsBefore).map((c) => ({ _id: c._id, stage: c.currentStage, status: "active" }));
     for (const ref of refs)
       mutation.history.push({
         _key: randomKey(),
         _type: "spawned",
         at: now,
-        task: task.name,
+        activity: activity.name,
         instanceRef: ref
       });
   }
-  await autoResolveOnActivate(ctx, mutation, task, entry, now, pendingChildren) || resolveMachineStep(mutation, task, entry, now);
+  await autoResolveOnActivate(ctx, mutation, activity, entry, now, pendingChildren) || resolveMachineStep(mutation, activity, entry, now);
 }
-async function autoResolveOnActivate(ctx, mutation, task, entry, now, pendingChildren) {
-  if (task.failWhen === void 0 && effectiveCompleteWhen(task) === void 0) return !1;
-  const vars = pendingChildren !== void 0 ? { subworkflows: pendingChildren } : await taskConditionVars(ctx, entry), outcome = await evaluateResolutionGate(ctx, task, vars);
-  return outcome === void 0 ? !1 : (applyTaskStatusChange({
+async function autoResolveOnActivate(ctx, mutation, activity, entry, now, pendingChildren) {
+  if (activity.failWhen === void 0 && effectiveCompleteWhen(activity) === void 0) return !1;
+  const vars = pendingChildren !== void 0 ? { subworkflows: pendingChildren } : await activityConditionVars(ctx, entry), outcome = await evaluateResolutionGate(ctx, activity, vars);
+  return outcome === void 0 ? !1 : (applyActivityStatusChange({
     entry,
     history: mutation.history,
     stage: mutation.currentStage,
@@ -2299,29 +2364,31 @@ async function autoResolveOnActivate(ctx, mutation, task, entry, now, pendingChi
     actor: gateActor(outcome)
   }), !0);
 }
-async function taskConditionVars(ctx, entry) {
+async function activityConditionVars(ctx, entry) {
   return entry.spawnedInstances === void 0 || entry.spawnedInstances.length === 0 ? { subworkflows: [] } : { subworkflows: await subworkflowRows(ctx, entry.spawnedInstances) };
 }
-function resolveMachineStep(mutation, task, entry, now) {
-  const waitsForActor = task.actions !== void 0 && task.actions.length > 0, waitsForCondition = task.completeWhen !== void 0 || task.subworkflows !== void 0;
-  waitsForActor || waitsForCondition || applyTaskStatusChange({
+function resolveMachineStep(mutation, activity, entry, now) {
+  const waitsForActor = activity.actions !== void 0 && activity.actions.length > 0, waitsForCondition = activity.completeWhen !== void 0 || activity.subworkflows !== void 0;
+  waitsForActor || waitsForCondition || applyActivityStatusChange({
     entry,
     history: mutation.history,
     stage: mutation.currentStage,
     to: "done",
     at: now,
-    actor: { kind: "system", id: "engine.machineStep" }
+    actor: engineSystemActor("machineStep")
   });
 }
-async function buildStageTasks(ctx, stage) {
+async function buildStageActivities(ctx, stage) {
   const entries = [];
-  for (const task of stage.tasks ?? []) {
-    const outcome = await ctxEvaluateConditionOutcome(ctx, task.filter, { taskName: task.name }), inScope = outcome !== "unsatisfied";
+  for (const activity of stage.activities ?? []) {
+    const outcome = await ctxEvaluateConditionOutcome(ctx, activity.filter, {
+      activityName: activity.name
+    }), inScope = outcome !== "unsatisfied";
     entries.push({
       _key: randomKey(),
-      name: task.name,
+      name: activity.name,
       status: inScope ? "pending" : "skipped",
-      ...task.filter !== void 0 ? { filterEvaluation: buildFilterEvaluation(ctx.now, task.filter, outcome) } : {}
+      ...activity.filter !== void 0 ? { filterEvaluation: buildFilterEvaluation(ctx.now, activity.filter, outcome) } : {}
     });
   }
   return entries;
@@ -2331,7 +2398,7 @@ function buildFilterEvaluation(at, filter, outcome) {
     at,
     truthy: !1,
     unevaluable: !0,
-    detail: `Filter "${filter}" could not be evaluated (GROQ null \u2014 a referenced operand was missing or incomparable). Task kept in scope so the gate is not silently skipped.`
+    detail: `Filter "${filter}" could not be evaluated (GROQ null \u2014 a referenced operand was missing or incomparable). Activity kept in scope so the gate is not silently skipped.`
   } : { at, truthy: outcome === "satisfied" };
 }
 function isTerminalStage(stage) {
@@ -2354,15 +2421,16 @@ async function enterStage(ctx, mutation, nextStage, actor, at) {
       client: ctx.client,
       instance: ctx.instance,
       stage: nextStage,
-      now: at
+      now: at,
+      recordDiscard: recordFieldDiscards(mutation.history, "stage", at)
     }),
-    tasks: await buildStageTasks(ctx, nextStage)
+    activities: await buildStageActivities(ctx, nextStage)
   };
   mutation.stages.push(nextStageEntry);
-  for (const task of nextStage.tasks ?? []) {
-    if (task.activation !== "auto") continue;
-    const entry = nextStageEntry.tasks.find((t) => t.name === task.name);
-    entry && entry.status === "pending" && await activateTask(ctx, mutation, task, entry, actor);
+  for (const activity of nextStage.activities ?? []) {
+    if (activity.activation !== "auto") continue;
+    const entry = nextStageEntry.activities.find((t) => t.name === activity.name);
+    entry && entry.status === "pending" && await activateActivity(ctx, mutation, activity, entry, actor);
   }
   isTerminalStage(nextStage) && (mutation.completedAt = at);
 }
@@ -2486,15 +2554,22 @@ async function primeInitialStage(client, instanceId, actor, clientForGdr, clock)
     instance,
     definition,
     ...clock ? { clock } : {}
-  }), now = ctx.now, initialStageEntry = {
+  }), now = ctx.now, discards = [], initialStageEntry = {
     _key: randomKey(),
     name: stage.name,
     enteredAt: now,
-    fields: await resolveStageFieldEntries({ client, instance, stage, now }),
-    tasks: await buildStageTasks(ctx, stage)
+    fields: await resolveStageFieldEntries({
+      client,
+      instance,
+      stage,
+      now,
+      recordDiscard: recordFieldDiscards(discards, "stage", now)
+    }),
+    activities: await buildStageActivities(ctx, stage)
   }, committed = await client.patch(instance._id).set({
     stages: [initialStageEntry],
-    lastChangedAt: now
+    lastChangedAt: now,
+    ...discards.length > 0 ? { history: [...instance.history, ...discards] } : {}
   }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
   await deployOrRollback({
     client,
@@ -2513,12 +2588,20 @@ async function primeInitialStage(client, instanceId, actor, clientForGdr, clock)
       stageName: stage.name,
       now
     })
-  }), await autoActivatePrimedTasks(client, instanceId, definition, stage, actor, clientForGdr, clock);
+  }), await autoActivatePrimedActivities(
+    client,
+    instanceId,
+    definition,
+    stage,
+    actor,
+    clientForGdr,
+    clock
+  );
 }
-async function autoActivatePrimedTasks(client, instanceId, definition, stage, actor, clientForGdr, clock) {
+async function autoActivatePrimedActivities(client, instanceId, definition, stage, actor, clientForGdr, clock) {
   const resolvedClientForGdr = clientForGdr ?? (() => client);
-  for (const task of stage.tasks ?? []) {
-    if (task.activation !== "auto") continue;
+  for (const activity of stage.activities ?? []) {
+    if (activity.activation !== "auto") continue;
     const updated = await client.getDocument(instanceId);
     if (!updated) continue;
     const updatedCtx = await buildEngineContext({
@@ -2527,18 +2610,22 @@ async function autoActivatePrimedTasks(client, instanceId, definition, stage, ac
       instance: updated,
       definition,
       ...clock ? { clock } : {}
-    }), mutation = startMutation(updated), mutEntry = currentTasks(mutation).find((t) => t.name === task.name);
-    mutEntry && mutEntry.status === "pending" && (await activateTask(updatedCtx, mutation, task, mutEntry, actor), await persist(updatedCtx, mutation));
+    }), mutation = startMutation(updated), mutEntry = currentActivities(mutation).find((t) => t.name === activity.name);
+    mutEntry && mutEntry.status === "pending" && (await activateActivity(updatedCtx, mutation, activity, mutEntry, actor), await persist(updatedCtx, mutation));
   }
 }
 const CASCADE_LIMIT = 100;
-async function gatherAutoResolveCandidates(ctx, tasks) {
-  const currentTasksList = findCurrentTasks(ctx.instance), candidates = [];
-  for (const task of tasks) {
-    const entry = currentTasksList.find((e) => e.name === task.name);
+async function gatherAutoResolveCandidates(ctx, activities) {
+  const currentActivitiesList = findCurrentActivities(ctx.instance), candidates = [];
+  for (const activity of activities) {
+    const entry = currentActivitiesList.find((e) => e.name === activity.name);
     if (entry?.status !== "active") continue;
-    const outcome = await evaluateResolutionGate(ctx, task, await taskConditionVars(ctx, entry));
-    outcome !== void 0 && candidates.push({ task, outcome });
+    const outcome = await evaluateResolutionGate(
+      ctx,
+      activity,
+      await activityConditionVars(ctx, entry)
+    );
+    outcome !== void 0 && candidates.push({ activity, outcome });
   }
   return candidates;
 }
@@ -2547,17 +2634,17 @@ async function resolveCompleteWhen(client, instanceId, clientForGdr, clock, over
     ...clientForGdr ? { clientForGdr } : {},
     ...clock ? { clock } : {},
     ...overlay ? { overlay } : {}
-  }), stage = findStage(ctx.definition, ctx.instance.currentStage), gatedTasks = (stage.tasks ?? []).filter(
+  }), stage = findStage(ctx.definition, ctx.instance.currentStage), gatedActivities = (stage.activities ?? []).filter(
     (t) => effectiveCompleteWhen(t) !== void 0 || t.failWhen !== void 0
   );
-  if (gatedTasks.length === 0) return 0;
-  const candidates = await gatherAutoResolveCandidates(ctx, gatedTasks);
+  if (gatedActivities.length === 0) return 0;
+  const candidates = await gatherAutoResolveCandidates(ctx, gatedActivities);
   if (candidates.length === 0) return 0;
   const mutation = startMutation(ctx.instance);
   let count = 0;
-  for (const { task, outcome } of candidates) {
-    const mutEntry = currentTasks(mutation).find((t) => t.name === task.name);
-    mutEntry === void 0 || mutEntry.status !== "active" || (applyTaskStatusChange({
+  for (const { activity, outcome } of candidates) {
+    const mutEntry = currentActivities(mutation).find((t) => t.name === activity.name);
+    mutEntry === void 0 || mutEntry.status !== "active" || (applyActivityStatusChange({
       entry: mutEntry,
       history: mutation.history,
       stage: stage.name,
@@ -2590,9 +2677,9 @@ async function findResolvedParentSpawn(client, child, clientForGdr, clock) {
   if (!parent || parent._type !== WORKFLOW_INSTANCE_TYPE || typeof parent.definitionSnapshot != "string") return;
   const definition = parseDefinitionSnapshot(parent), stage = definition.stages.find((s) => s.name === parent.currentStage);
   if (stage === void 0) return;
-  const parentCurrentTasks = findCurrentTasks(parent), task = (stage.tasks ?? []).find((t) => t.subworkflows === void 0 ? !1 : parentCurrentTasks.find((e) => e.name === t.name)?.spawnedInstances?.some((r) => gdrToBareId(r.id) === child._id) ?? !1);
-  if (task?.subworkflows === void 0) return;
-  const entry = parentCurrentTasks.find((e) => e.name === task.name);
+  const parentCurrentActivities = findCurrentActivities(parent), activity = (stage.activities ?? []).find((t) => t.subworkflows === void 0 ? !1 : parentCurrentActivities.find((e) => e.name === t.name)?.spawnedInstances?.some((r) => gdrToBareId(r.id) === child._id) ?? !1);
+  if (activity?.subworkflows === void 0) return;
+  const entry = parentCurrentActivities.find((e) => e.name === activity.name);
   if (entry === void 0 || entry.status !== "active") return;
   const ctx = await buildEngineContext({
     client,
@@ -2600,23 +2687,27 @@ async function findResolvedParentSpawn(client, child, clientForGdr, clock) {
     instance: parent,
     definition,
     ...clock ? { clock } : {}
-  }), outcome = await evaluateResolutionGate(ctx, task, await taskConditionVars(ctx, entry));
+  }), outcome = await evaluateResolutionGate(
+    ctx,
+    activity,
+    await activityConditionVars(ctx, entry)
+  );
   if (outcome !== void 0)
-    return { parent, definition, stage, task, outcome };
+    return { parent, definition, stage, activity, outcome };
 }
 async function propagateToAncestors(client, instanceId, actor, clientForGdr, clock) {
   const instance = await client.getDocument(instanceId);
   if (!instance) return;
   const resolvedClientForGdr = clientForGdr ?? (() => client), found = await findResolvedParentSpawn(client, instance, resolvedClientForGdr, clock);
   if (found === void 0) return;
-  const { parent, definition, stage, task, outcome } = found, ctx = await buildEngineContext({
+  const { parent, definition, stage, activity, outcome } = found, ctx = await buildEngineContext({
     client,
     clientForGdr: resolvedClientForGdr,
     instance: parent,
     definition,
     ...clock ? { clock } : {}
-  }), mutation = startMutation(parent), mutEntry = currentTasks(mutation).find((e) => e.name === task.name);
-  mutEntry !== void 0 && (applyTaskStatusChange({
+  }), mutation = startMutation(parent), mutEntry = currentActivities(mutation).find((e) => e.name === activity.name);
+  mutEntry !== void 0 && (applyActivityStatusChange({
     entry: mutEntry,
     history: mutation.history,
     stage: stage.name,
@@ -2719,6 +2810,18 @@ async function fetchGrantsCached(requestFn, resourcePath) {
     return;
   }
 }
+function hasItems(arr) {
+  return arr !== void 0 && arr.length > 0;
+}
+function deriveActivityKind(activity) {
+  return hasItems(activity.actions) ? "user" : hasItems(activity.effects) ? "service" : activity.completeWhen !== void 0 || activity.subworkflows !== void 0 ? "receive" : "script";
+}
+function activityKind(activity) {
+  return activity.kind ?? deriveActivityKind(activity);
+}
+function driverKind(actor) {
+  return actor.kind === "user" ? "person" : actor.kind === "ai" ? "agent" : isEngineActor(actor) ? "engine" : "service";
+}
 function effectiveEditable(baseline, override) {
   if (baseline === void 0) return;
   if (override === void 0) return baseline;
@@ -2730,14 +2833,15 @@ function slotSites(definition, stage) {
   const sites = [];
   for (const entry of definition.fields ?? []) sites.push({ scope: "workflow", entry });
   for (const entry of stage.fields ?? []) sites.push({ scope: "stage", entry });
-  for (const task of stage.tasks ?? [])
-    for (const entry of task.fields ?? []) sites.push({ scope: "task", task: task.name, entry });
+  for (const activity of stage.activities ?? [])
+    for (const entry of activity.fields ?? [])
+      sites.push({ scope: "activity", activity: activity.name, entry });
   return sites;
 }
 function toResolvedSlot(site, stage) {
   return {
     scope: site.scope,
-    ...site.task !== void 0 ? { task: site.task } : {},
+    ...site.activity !== void 0 ? { activity: site.activity } : {},
     name: site.entry.name,
     type: site.entry.type,
     ...site.entry.title !== void 0 ? { title: site.entry.title } : {},
@@ -2749,16 +2853,16 @@ function editableSlotsInStage(definition, stage) {
   return slotSites(definition, stage).filter((site) => site.entry.editable !== void 0).map((site) => toResolvedSlot(site, stage));
 }
 function editTargetMatches(slot, target) {
-  return slot.name !== target.field ? !1 : target.task !== void 0 ? slot.scope === "task" && slot.task === target.task : target.scope !== void 0 ? slot.scope === target.scope : !0;
+  return slot.name !== target.field ? !1 : target.activity !== void 0 ? slot.scope === "activity" && slot.activity === target.activity : target.scope !== void 0 ? slot.scope === target.scope : !0;
 }
-const SCOPE_PRECEDENCE = { task: 0, stage: 1, workflow: 2 };
+const SCOPE_PRECEDENCE = { activity: 0, stage: 1, workflow: 2 };
 function resolveEditTarget(args) {
   const { definition, stage, target } = args, found = slotSites(definition, stage).filter(
     (site) => editTargetMatches(
       {
         scope: site.scope,
         name: site.entry.name,
-        ...site.task !== void 0 ? { task: site.task } : {}
+        ...site.activity !== void 0 ? { activity: site.activity } : {}
       },
       target
     )
@@ -2768,9 +2872,11 @@ function resolveEditTarget(args) {
 function slotWindowOpen(instance, slot) {
   if (instance.completedAt !== void 0) return { open: !1, detail: "instance completed" };
   if (instance.abortedAt !== void 0) return { open: !1, detail: "instance aborted" };
-  if (slot.scope !== "task") return { open: !0 };
-  const status = findOpenStageEntry(instance)?.tasks.find((t) => t.name === slot.task)?.status;
-  return status === "active" ? { open: !0 } : { open: !1, detail: `task "${slot.task}" is ${status ?? "not active"}` };
+  if (slot.scope !== "activity") return { open: !0 };
+  const status = findOpenStageEntry(instance)?.activities.find(
+    (t) => t.name === slot.activity
+  )?.status;
+  return status === "active" ? { open: !0 } : { open: !1, detail: `activity "${slot.activity}" is ${status ?? "not active"}` };
 }
 function readSlotValue(instance, slot) {
   return slotFieldHost(instance, slot)?.find((e) => e.name === slot.name)?.value;
@@ -2778,7 +2884,7 @@ function readSlotValue(instance, slot) {
 function slotFieldHost(instance, slot) {
   if (slot.scope === "workflow") return instance.fields;
   const stageEntry = findOpenStageEntry(instance);
-  return slot.scope === "stage" ? stageEntry?.fields : stageEntry?.tasks.find((t) => t.name === slot.task)?.fields;
+  return slot.scope === "stage" ? stageEntry?.fields : stageEntry?.activities.find((t) => t.name === slot.activity)?.fields;
 }
 function slotProvenance(instance, ref) {
   let latest;
@@ -2821,12 +2927,12 @@ async function evaluateFromSnapshot(args) {
     throw new Error(
       `Instance "${instance._id}" currentStage "${instance.currentStage}" not in definition`
     );
-  const scope = await renderScope({ instance, definition, actor, grants, snapshot, now }), currentTaskEntries = findOpenStageEntry(instance)?.tasks ?? [], guardDenial = await instanceGuardReason(instance, actor, args.guards), taskEvaluations = [];
-  for (const task of stage.tasks ?? [])
-    taskEvaluations.push(
-      await evaluateTask({
-        task,
-        statusEntry: currentTaskEntries.find((t) => t.name === task.name),
+  const scope = await renderScope({ instance, definition, actor, grants, snapshot, now }), currentActivityEntries = findOpenStageEntry(instance)?.activities ?? [], guardDenial = await instanceGuardReason(instance, actor, args.guards), activityEvaluations = [];
+  for (const activity of stage.activities ?? [])
+    activityEvaluations.push(
+      await evaluateActivity({
+        activity,
+        statusEntry: currentActivityEntries.find((t) => t.name === activity.name),
         instance,
         actor,
         snapshot,
@@ -2851,9 +2957,9 @@ async function evaluateFromSnapshot(args) {
   }
   const currentStage = {
     stage,
-    tasks: taskEvaluations,
+    activities: activityEvaluations,
     transitions: transitionEvaluations
-  }, pendingOnYou = taskEvaluations.filter((t) => t.pendingOnActor), canInteract = taskEvaluations.some((t) => t.actions.some((a) => a.allowed)), editGuardDenial = guardDenial?.kind === "mutation-guard-denied" ? guardDenial : void 0, editableSlots = await evaluateEditableSlots({
+  }, pendingOnYou = activityEvaluations.filter((t) => t.pendingOnActor), canInteract = activityEvaluations.some((t) => t.actions.some((a) => a.allowed)), editGuardDenial = guardDenial?.kind === "mutation-guard-denied" ? guardDenial : void 0, editableSlots = await evaluateEditableSlots({
     instance,
     definition,
     stage,
@@ -2893,7 +2999,7 @@ async function evaluateEditableSlots(args) {
     }), value = readSlotValue(instance, slot);
     slots.push({
       scope: slot.scope,
-      ...slot.task !== void 0 ? { task: slot.task } : {},
+      ...slot.activity !== void 0 ? { activity: slot.activity } : {},
       name: slot.name,
       type: slot.type,
       ...slot.title !== void 0 ? { title: slot.title } : {},
@@ -2909,7 +3015,14 @@ async function editPredicateSatisfied(args) {
   const { slot, window, guardDenial, instance, snapshot, scope, actor, roleAliases } = args;
   if (!window.open || guardDenial !== void 0) return !1;
   if (slot.effective === !0) return !0;
-  const params = slot.scope === "task" && slot.task !== void 0 ? taskScopeFor({ scope, instance, snapshot, actor, taskName: slot.task, roleAliases }) : scope;
+  const params = slot.scope === "activity" && slot.activity !== void 0 ? activityScopeFor({
+    scope,
+    instance,
+    snapshot,
+    actor,
+    activityName: slot.activity,
+    roleAliases
+  }) : scope;
   return evaluateCondition({ condition: slot.effective, snapshot, params });
 }
 async function renderScope(args) {
@@ -2937,20 +3050,20 @@ async function advisoryCan(instance, actor, grants) {
     });
   return can;
 }
-function taskScopeFor(args) {
-  const { scope, instance, snapshot, actor, taskName, roleAliases } = args;
+function activityScopeFor(args) {
+  const { scope, instance, snapshot, actor, activityName, roleAliases } = args;
   return {
     ...scope,
     fields: {
       ...scope.fields,
-      ...scopedFieldOverlay(instance, snapshot, taskName)
+      ...scopedFieldOverlay(instance, snapshot, activityName)
     },
-    assigned: assignedFor(instance, taskName, actor, roleAliases)
+    assigned: assignedFor(instance, activityName, actor, roleAliases)
   };
 }
-async function evaluateTask(args) {
+async function evaluateActivity(args) {
   const {
-    task,
+    activity,
     statusEntry,
     instance,
     actor,
@@ -2959,36 +3072,37 @@ async function evaluateTask(args) {
     roleAliases,
     stageHasExits,
     guardDenial
-  } = args, status = statusEntry?.status ?? "pending", taskScope = taskScopeFor({
+  } = args, status = statusEntry?.status ?? "pending", activityScope = activityScopeFor({
     scope,
     instance,
     snapshot,
     actor,
-    taskName: task.name,
+    activityName: activity.name,
     roleAliases
-  }), assigned = taskScope.assigned === !0, unmetRequirements = await evaluateRequirements({
-    requirements: task.requirements,
+  }), assigned = activityScope.assigned === !0, unmetRequirements = await evaluateRequirements({
+    requirements: activity.requirements,
     snapshot,
-    params: taskScope
+    params: activityScope
   }), requirementsReason = unmetRequirements.length > 0 ? { kind: "requirements-unmet", unmetRequirements } : void 0, actions = [];
-  for (const action of task.actions ?? [])
+  for (const action of activity.actions ?? [])
     actions.push(
       await evaluateAction({
         action,
         status,
         instance,
         snapshot,
-        taskScope,
+        activityScope,
         stageHasExits,
         guardDenial,
         requirementsReason
       })
     );
   return {
-    task,
+    activity,
     status,
+    kind: activityKind(activity),
     // "pending on actor" treats both `pending` and `active` as waiting on
-    // the assignee — pending tasks just haven't been activated yet, but
+    // the assignee — pending activities just haven't been activated yet, but
     // they're still inbox items. The inbox reads the assignees-kind field
     // entry BY KIND (who-data is fields).
     pendingOnActor: (status === "active" || status === "pending") && assigned,
@@ -3002,7 +3116,7 @@ async function evaluateAction(args) {
     status,
     instance,
     snapshot,
-    taskScope,
+    activityScope,
     stageHasExits,
     guardDenial,
     requirementsReason
@@ -3010,7 +3124,7 @@ async function evaluateAction(args) {
   return lifecycle !== void 0 ? disabled(action, lifecycle) : guardDenial !== void 0 ? disabled(action, guardDenial) : requirementsReason !== void 0 ? disabled(action, requirementsReason) : action.filter !== void 0 && !await evaluateCondition({
     condition: action.filter,
     snapshot,
-    params: taskScope
+    params: activityScope
   }) ? disabled(action, { kind: "filter-failed", filter: action.filter }) : { action, allowed: !0 };
 }
 async function instanceGuardReason(instance, actor, guards) {
@@ -3028,8 +3142,8 @@ function lifecycleReason(instance, status, stageHasExits) {
     return { kind: "instance-completed", completedAt: instance.completedAt };
   if (!stageHasExits)
     return { kind: "stage-terminal", stage: instance.currentStage };
-  if (schema.isTerminalTaskStatus(status))
-    return { kind: "task-not-active", status };
+  if (schema.isTerminalActivityStatus(status))
+    return { kind: "activity-not-active", status };
 }
 function disabled(action, reason) {
   return { action, allowed: !1, disabledReason: reason };
@@ -3037,37 +3151,30 @@ function disabled(action, reason) {
 function definitionDocId(_workflowResource, tag, definition, version) {
   return `${tag}.${definition}.v${version}`;
 }
-async function sortByDependencies(client, definitions, tag, workflowResource) {
+async function sortByDependencies(client, definitions, tag) {
   const byName = /* @__PURE__ */ new Map();
   for (const def of definitions) {
-    const list = byName.get(def.name) ?? [];
-    list.push(def), byName.set(def.name, list);
+    if (byName.has(def.name))
+      throw new Error(
+        `workflow.deployDefinitions: duplicate definition name "${def.name}" in batch \u2014 names identify a batch member (versions are deploy-assigned, not authored)`
+      );
+    byName.set(def.name, def);
   }
   const findInBatch = (ref) => findRefInBatch(byName, ref);
-  return await assertCrossBatchRefsDeployed(client, definitions, {
-    tag,
-    workflowResource,
-    findInBatch
-  }), topoSortDefinitions(definitions, { workflowResource, tag, findInBatch });
+  return await assertCrossBatchRefsDeployed(client, definitions, { tag, findInBatch }), topoSortDefinitions(definitions, { findInBatch });
 }
 function findRefInBatch(byName, ref) {
-  const candidates = byName.get(ref.name);
-  if (!(candidates === void 0 || candidates.length === 0))
-    return typeof ref.version == "number" ? candidates.find((c) => c.version === ref.version) : candidates.reduce(
-      (best, c) => best === void 0 || c.version > best.version ? c : best,
-      void 0
-    );
+  if (typeof ref.version != "number")
+    return byName.get(ref.name);
 }
 async function assertCrossBatchRefsDeployed(client, definitions, ctx) {
   const missing = [];
-  for (const def of definitions) {
-    const fromId = definitionDocId(ctx.workflowResource, ctx.tag, def.name, def.version);
+  for (const def of definitions)
     for (const ref of refsOf(def)) {
       if (ctx.findInBatch(ref) !== void 0) continue;
       const label = await resolveDeployedRefLabel(client, ref, ctx.tag);
-      label !== void 0 && missing.push({ from: fromId, ref: label });
+      label !== void 0 && missing.push({ from: def.name, ref: label });
     }
-  }
   if (missing.length === 0) return;
   const lines = missing.map((m) => `  - ${m.from} \u2192 ${m.ref} (neither in batch nor deployed)`);
   throw new Error(
@@ -3086,16 +3193,15 @@ async function resolveDeployedRefLabel(client, ref, tag) {
 }
 function topoSortDefinitions(definitions, ctx) {
   const visited = /* @__PURE__ */ new Set(), visiting = /* @__PURE__ */ new Set(), ordered = [], visit = (def) => {
-    const id = definitionDocId(ctx.workflowResource, ctx.tag, def.name, def.version);
-    if (!visited.has(id)) {
-      if (visiting.has(id))
-        throw new Error(`workflow.deployDefinitions: dependency cycle involving "${id}"`);
-      visiting.add(id);
+    if (!visited.has(def.name)) {
+      if (visiting.has(def.name))
+        throw new Error(`workflow.deployDefinitions: dependency cycle involving "${def.name}"`);
+      visiting.add(def.name);
       for (const ref of refsOf(def)) {
         const child = ctx.findInBatch(ref);
         child !== void 0 && visit(child);
       }
-      visiting.delete(id), visited.add(id), ordered.push(def);
+      visiting.delete(def.name), visited.add(def.name), ordered.push(def);
     }
   };
   for (const def of definitions) visit(def);
@@ -3104,8 +3210,8 @@ function topoSortDefinitions(definitions, ctx) {
 function refsOf(def) {
   const out = [];
   for (const stage of def.stages)
-    for (const task of stage.tasks ?? []) {
-      const ref = task.subworkflows?.definition;
+    for (const activity of stage.activities ?? []) {
+      const ref = activity.subworkflows?.definition;
       ref !== void 0 && out.push({
         name: ref.name,
         ...ref.version !== void 0 ? { version: ref.version } : {}
@@ -3113,8 +3219,23 @@ function refsOf(def) {
     }
   return out;
 }
-function isDefinitionUnchanged(existing, expected) {
-  return stableStringify(stripSystemFields(existing)) === stableStringify(stripSystemFields(expected));
+function hashDefinitionContent(def) {
+  const canonical = stableStringify(def);
+  let hash = 0xcbf29ce484222325n;
+  for (let i = 0; i < canonical.length; i++)
+    hash ^= BigInt(canonical.charCodeAt(i)), hash = hash * 0x100000001b3n & 0xffffffffffffffffn;
+  return hash.toString(16).padStart(16, "0");
+}
+function planDefinitionDeploy(def, latest, target) {
+  const contentHash = hashDefinitionContent(def), unchanged = latest !== void 0 && latest.contentHash === contentHash, version = unchanged ? latest.version : (latest?.version ?? 0) + 1, docId = definitionDocId(target.workflowResource, target.tag, def.name, version), document = {
+    ...def,
+    _id: docId,
+    _type: schema.WORKFLOW_DEFINITION_TYPE,
+    tag: target.tag,
+    version,
+    contentHash
+  };
+  return { status: unchanged ? "unchanged" : "create", version, contentHash, docId, document };
 }
 function stripSystemFields(doc) {
   const out = {};
@@ -3129,22 +3250,26 @@ function stableStringify(value) {
 }
 async function loadDefinition(client, definition, version, tag) {
   if (version !== void 0) {
-    const doc = await client.fetch(
-      definitionLookupGroq(!0),
-      { definition, version, tag }
-    );
+    const doc = await client.fetch(definitionLookupGroq(!0), {
+      definition,
+      version,
+      tag
+    });
     if (!doc)
       throw new Error(`Workflow definition ${definition} v${version} not deployed`);
     return doc;
   }
-  const latest = await client.fetch(definitionLookupGroq(!1), {
-    definition,
-    tag
-  });
+  const latest = await loadLatestDeployed(client, definition, tag);
   if (!latest)
     throw new Error(`No deployed definition for workflow ${definition}`);
   return latest;
 }
+async function loadLatestDeployed(client, definition, tag) {
+  return await client.fetch(definitionLookupGroq(!1), {
+    definition,
+    tag
+  }) ?? void 0;
+}
 async function loadDefinitionVersions(client, definition, tag) {
   return client.fetch(
     `*[_type == "${schema.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${tagScopeFilter()}] | order(version desc)`,
@@ -3191,63 +3316,63 @@ async function commitAbort(ctx, reason, actor) {
   }), { fired: !0, stage: stage.name };
 }
 async function fireAction(args) {
-  const { client, instanceId, task, action, params, options } = args;
+  const { client, instanceId, activity, action, params, options } = args;
   for (let attempt = 1; attempt <= CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS; attempt++) {
     const ctx = await loadCallContext(client, instanceId, options);
     try {
-      return await commitAction(ctx, task, action, params, options);
+      return await commitAction(ctx, activity, action, params, options);
     } catch (error) {
       if (!isRevisionConflict(error)) throw error;
     }
   }
   throw new ConcurrentFireActionError({
     instanceId,
-    task,
+    activity,
     action,
     attempts: CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS
   });
 }
-async function resolveActionCommit(ctx, taskName, actionName, callerParams, options) {
-  const actor = options?.actor, { stage, task } = findTaskInCurrentStage(ctx, taskName), action = (task.actions ?? []).find((a) => a.name === actionName);
+async function resolveActionCommit(ctx, activityName, actionName, callerParams, options) {
+  const actor = options?.actor, { stage, activity } = findActivityInCurrentStage(ctx, activityName), action = (activity.actions ?? []).find((a) => a.name === actionName);
   if (action === void 0)
-    throw new Error(`Action "${actionName}" not declared on task "${taskName}"`);
+    throw new Error(`Action "${actionName}" not declared on activity "${activityName}"`);
   const can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan(ctx.instance, actor, options.grants) : void 0;
   if (!await ctxEvaluateCondition(ctx, action.filter, {
-    taskName,
+    activityName,
     ...actor !== void 0 ? { actor } : {},
     ...can !== void 0 ? { vars: { can } } : {}
   }))
-    throw new Error(`Action "${actionName}" filter rejected on task "${taskName}"`);
-  const entry = findCurrentTasks(ctx.instance).find((t) => t.name === taskName);
+    throw new Error(`Action "${actionName}" filter rejected on activity "${activityName}"`);
+  const entry = findCurrentActivities(ctx.instance).find((t) => t.name === activityName);
   if (entry === void 0 || entry.status !== "active")
     throw new Error(
-      `Task "${taskName}" must be active to fire action "${actionName}"; status is ${entry?.status ?? "missing"}`
+      `Activity "${activityName}" must be active to fire action "${actionName}"; status is ${entry?.status ?? "missing"}`
     );
-  const params = validateActionParams(action, taskName, callerParams);
-  return { stage, task, action, params };
+  const params = validateActionParams(action, activityName, callerParams);
+  return { stage, activity, action, params };
 }
-async function commitAction(ctx, taskName, actionName, callerParams, options) {
+async function commitAction(ctx, activityName, actionName, callerParams, options) {
   const actor = options?.actor, { stage, action, params } = await resolveActionCommit(
     ctx,
-    taskName,
+    activityName,
     actionName,
     callerParams,
     options
-  ), mutation = startMutation(ctx.instance), mutEntry = requireMutationTaskEntry(mutation, taskName), now = ctx.now;
+  ), mutation = startMutation(ctx.instance), mutEntry = requireMutationActivityEntry(mutation, activityName), now = ctx.now;
   mutation.history.push({
     _key: randomKey(),
     _type: "actionFired",
     at: now,
     stage: stage.name,
-    task: taskName,
+    activity: activityName,
     action: actionName,
-    ...actor !== void 0 ? { actor } : {}
+    ...actor !== void 0 ? { actor, driverKind: driverKind(actor) } : {}
   });
   const statusBefore = mutEntry.status, ranOps = await runOps({
     ops: action.ops,
     mutation,
     stage: stage.name,
-    origin: { task: taskName, action: actionName },
+    origin: { activity: activityName, action: actionName },
     params,
     actor,
     self: selfGdr(ctx.instance),
@@ -3255,14 +3380,14 @@ async function commitAction(ctx, taskName, actionName, callerParams, options) {
   }), newStatus = mutEntry.status !== statusBefore ? mutEntry.status : void 0;
   return await queueEffects(ctx, mutation, action.effects, { kind: "action", name: actionName }, actor, {
     callerParams: params,
-    taskName
+    activityName
   }), await persistThenDeploy(
     ctx,
     mutation,
     () => ranOps.some(isFieldOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
   ), {
     fired: !0,
-    task: taskName,
+    activity: activityName,
     action: actionName,
     ...newStatus !== void 0 ? { newStatus } : {},
     ...ranOps.length > 0 ? { ranOps } : {}
@@ -3270,23 +3395,23 @@ async function commitAction(ctx, taskName, actionName, callerParams, options) {
 }
 class ActionDisabledError extends Error {
   reason;
-  task;
+  activity;
   action;
   constructor(args) {
-    super(formatDisabledReason(args.task, args.action, args.reason)), this.name = "ActionDisabledError", this.reason = args.reason, this.task = args.task, this.action = args.action;
+    super(formatDisabledReason(args.activity, args.action, args.reason)), this.name = "ActionDisabledError", this.reason = args.reason, this.activity = args.activity, this.action = args.action;
   }
 }
 const disabledReasonDetail = {
   "filter-failed": (r) => `action filter returned false${r.detail ? ` (${r.detail})` : ""}`,
-  "task-not-active": (r) => `task status is "${r.status}"`,
+  "activity-not-active": (r) => `activity status is "${r.status}"`,
   "stage-terminal": (r) => `stage "${r.stage}" is terminal`,
   "instance-completed": (r) => `instance completed at ${r.completedAt}`,
   "mutation-guard-denied": (r) => `blocked by mutation guard(s) [${r.guardIds.join(", ")}]${r.detail ? ` (${r.detail})` : ""}`,
   "requirements-unmet": (r) => `unmet requirement(s): ${r.unmetRequirements.join(", ")}`
 };
-function formatDisabledReason(task, action, reason) {
+function formatDisabledReason(activity, action, reason) {
   const detail = disabledReasonDetail[reason.kind](reason);
-  return `Action "${task}:${action}" is not allowed: ${detail}`;
+  return `Action "${activity}:${action}" is not allowed: ${detail}`;
 }
 class EditFieldDeniedError extends Error {
   reason;
@@ -3305,7 +3430,7 @@ const editDisabledReasonDetail = {
 function formatEditDisabledReason(target, reason) {
   const detail = editDisabledReasonDetail[reason.kind](
     reason
-  ), where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
+  ), where = target.activity !== void 0 ? `${target.activity}.${target.field}` : target.field;
   return `Field "${target.scope}:${where}" is not editable: ${detail}`;
 }
 async function editField(args) {
@@ -3337,7 +3462,7 @@ async function commitEdit(ctx, target, mode, value, options) {
     stage: stage.name,
     origin: {
       edit: !0,
-      ...slot.scope === "task" && slot.task !== void 0 ? { task: slot.task } : {}
+      ...slot.scope === "activity" && slot.activity !== void 0 ? { activity: slot.activity } : {}
     },
     params: {},
     actor,
@@ -3356,7 +3481,7 @@ async function commitEdit(ctx, target, mode, value, options) {
 }
 async function assertSlotEditable(ctx, slot, options) {
   const actor = options?.actor, window = slotWindowOpen(ctx.instance, slot), can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan(ctx.instance, actor, options.grants) : void 0, predicateSatisfied = window.open && slot.effective !== !0 && slot.effective !== void 0 ? await ctxEvaluateCondition(ctx, slot.effective, {
-    ...slot.task !== void 0 ? { taskName: slot.task } : {},
+    ...slot.activity !== void 0 ? { activityName: slot.activity } : {},
     ...actor !== void 0 ? { actor } : {},
     ...can !== void 0 ? { vars: { can } } : {}
   }) : slot.effective === !0, reason = editDisabledReason({
@@ -3382,18 +3507,18 @@ function slotTarget(slot) {
   return {
     scope: slot.scope,
     field: slot.name,
-    ...slot.task !== void 0 ? { task: slot.task } : {}
+    ...slot.activity !== void 0 ? { activity: slot.activity } : {}
   };
 }
 function labelTarget(target) {
   return {
-    scope: target.scope ?? (target.task !== void 0 ? "task" : "workflow"),
+    scope: target.scope ?? (target.activity !== void 0 ? "activity" : "workflow"),
     field: target.field,
-    ...target.task !== void 0 ? { task: target.task } : {}
+    ...target.activity !== void 0 ? { activity: target.activity } : {}
   };
 }
 function describeTarget(target) {
-  const where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
+  const where = target.activity !== void 0 ? `${target.activity}.${target.field}` : target.field;
   return target.scope !== void 0 ? `${target.scope}:${where}` : where;
 }
 function bareIdFromSpawnRef(uri) {
@@ -3458,10 +3583,10 @@ async function dispatchGatedWrite(args) {
     ...ranOps !== void 0 ? { ranOps } : {}
   };
 }
-function assertActionAllowed(evaluation, task, action) {
-  const actionEval = evaluation.currentStage.tasks.find((t) => t.task.name === task)?.actions.find((a) => a.action.name === action);
+function assertActionAllowed(evaluation, activity, action) {
+  const actionEval = evaluation.currentStage.activities.find((t) => t.activity.name === activity)?.actions.find((a) => a.action.name === action);
   if (actionEval?.allowed === !1 && actionEval.disabledReason)
-    throw new ActionDisabledError({ task, action, reason: actionEval.disabledReason });
+    throw new ActionDisabledError({ activity, action, reason: actionEval.disabledReason });
 }
 function assertEditAllowed(evaluation, target) {
   const slot = evaluation.editableSlots.filter((s) => editTargetMatches(s, target)).sort((a, b) => SCOPE_PRECEDENCE[a.scope] - SCOPE_PRECEDENCE[b.scope])[0];
@@ -3470,7 +3595,7 @@ function assertEditAllowed(evaluation, target) {
       target: {
         scope: slot.scope,
         field: slot.name,
-        ...slot.task !== void 0 ? { task: slot.task } : {}
+        ...slot.activity !== void 0 ? { activity: slot.activity } : {}
       },
       reason: slot.disabledReason
     });
@@ -3495,11 +3620,11 @@ function buildEngineCallOptions(args) {
   };
 }
 async function applyAction(args) {
-  const { client, instance, task, action, params, actor, grants, clock, clientForGdr } = args, options = buildEngineCallOptions({ actor, grants, clock, clientForGdr });
-  return findOpenStageEntry(instance)?.tasks.find((t) => t.name === task)?.status === "pending" && await invokeTask({ client, instanceId: instance._id, task, options }), (await fireAction({
+  const { client, instance, activity, action, params, actor, grants, clock, clientForGdr } = args, options = buildEngineCallOptions({ actor, grants, clock, clientForGdr });
+  return findOpenStageEntry(instance)?.activities.find((t) => t.name === activity)?.status === "pending" && await invokeActivity({ client, instanceId: instance._id, activity, options }), (await fireAction({
     client,
     instanceId: instance._id,
-    task,
+    activity,
     action,
     ...params !== void 0 ? { params } : {},
     options
@@ -3579,14 +3704,16 @@ function previewIds(ids) {
 }
 const workflow = {
   /**
-   * Deploy a set of workflow definitions as one call. Each lands as a
-   * {@link WORKFLOW_DEFINITION_TYPE} document; subsequent versions are
-   * stored alongside earlier ones — `startInstance` picks the highest
-   * version by default. The SDK figures out the dependency order itself
-   * (children before parents that spawn them via
-   * `subworkflows.definition`), idempotently writes any definition
-   * whose content has changed, and reports a per-definition outcome
-   * (`created` / `updated` / `unchanged`).
+   * Deploy a set of workflow definitions as one call. Definitions are
+   * immutable and content-addressed: the author writes no version, and each
+   * deploy compares a definition's content fingerprint to the latest version
+   * already deployed under its name. Identical content is a no-op
+   * (`unchanged`); any change mints the next version (`created`) — deploy
+   * never patches a deployed version, so a definition can't change out from
+   * under the instances pinned to it. `startInstance` picks the highest
+   * version by default. The engine figures out the dependency order itself
+   * (children before parents that spawn them via `subworkflows.definition`)
+   * and reports a per-definition outcome (`created` / `unchanged`).
    *
    * Refs may point inside the batch OR at already-deployed definitions
    * in the lake — both are valid. A ref pointing at neither errors with
@@ -3599,31 +3726,15 @@ const workflow = {
     validateTag(tag);
     for (const def of definitions)
       validateDefinition(def);
-    const ordered = await sortByDependencies(client, definitions, tag, workflowResource), results = [], tx = client.transaction();
+    const ordered = await sortByDependencies(client, definitions, tag), results = [], tx = client.transaction();
     let hasWrites = !1;
     for (const def of ordered) {
-      const id = definitionDocId(workflowResource, tag, def.name, def.version), expected = {
-        ...def,
-        _id: id,
-        _type: schema.WORKFLOW_DEFINITION_TYPE,
-        tag
-      }, existing = await client.getDocument(id);
-      if (existing && existing.tag === tag && isDefinitionUnchanged(existing, expected)) {
-        results.push({ definition: def.name, version: def.version, status: "unchanged" });
+      const latest = await loadLatestDeployed(client, def.name, tag), plan = planDefinitionDeploy(def, latest, { tag, workflowResource });
+      if (plan.status === "unchanged") {
+        results.push({ definition: def.name, version: plan.version, status: "unchanged" });
         continue;
       }
-      if (existing) {
-        const expectedKeys = new Set(Object.keys(expected)), toUnset = Object.keys(existing).filter(
-          (k) => !k.startsWith("_") && !expectedKeys.has(k)
-        ), patch = client.patch(id).set(expected).ifRevisionId(existing._rev);
-        toUnset.length > 0 && patch.unset(toUnset), tx.patch(patch);
-      } else
-        tx.create(expected);
-      hasWrites = !0, results.push({
-        definition: def.name,
-        version: def.version,
-        status: existing ? "updated" : "created"
-      });
+      tx.create(plan.document), hasWrites = !0, results.push({ definition: def.name, version: plan.version, status: "created" });
     }
     return hasWrites && await tx.commit(), { results };
   },
@@ -3639,8 +3750,8 @@ const workflow = {
    * Spawn a new workflow instance from a deployed definition.
    *
    * Pins the snapshot at start-time, seeds `effectsContext`, enters
-   * the initial stage (which builds taskStatus, queues onEnter
-   * effects, auto-activates tasks). Then cascades auto-transitions
+   * the initial stage (which builds activityStatus, queues onEnter
+   * effects, auto-activates activities). Then cascades auto-transitions
    * until stable. Returns the resulting instance.
    */
   startInstance: async (args) => {
@@ -3660,7 +3771,7 @@ const workflow = {
       throw new Error(
         `Initial stage "${definition.initialStage}" missing in ${definitionName} v${definition.version}`
       );
-    const now = clock(), effectsContextEntries = effectsContext ? toEffectsContextEntries(effectsContext) : [], resolvedFields = await resolveDeclaredFields({
+    const now = clock(), effectsContextEntries = effectsContext ? toEffectsContextEntries(effectsContext) : [], fieldDiscards = [], resolvedFields = await resolveDeclaredFields({
       entryDefs: definition.fields ?? [],
       initialFields: initialFields ?? [],
       ctx: {
@@ -3670,7 +3781,8 @@ const workflow = {
         tag,
         workflowResource,
         definitionName: definition.name,
-        ...perspective !== void 0 ? { perspective } : {}
+        ...perspective !== void 0 ? { perspective } : {},
+        recordDiscard: recordFieldDiscards(fieldDiscards, "workflow", now)
       },
       randomKey
     }), effectivePerspective = perspective ?? derivePerspectiveFromFields(resolvedFields), base = buildInstanceBase({
@@ -3680,18 +3792,20 @@ const workflow = {
       workflowResource,
       definitionName: definition.name,
       pinnedVersion: definition.version,
+      pinnedContentHash: definition.contentHash,
       definition,
       fields: resolvedFields,
       effectsContext: effectsContextEntries,
       ancestors: ancestors ?? [],
       perspective: effectivePerspective,
       initialStage: definition.initialStage,
-      actor
+      actor,
+      ...fieldDiscards.length > 0 ? { extraHistory: fieldDiscards } : {}
     });
     return await client.create(base, SYNC_COMMIT), await primeInitialStage(client, id, actor, clientForGdr, clock), await cascade(client, id, actor, clientForGdr, clock), reload(client, id, tag);
   },
   /**
-   * Fire an action against a task. If the task is pending, it is
+   * Fire an action against an activity. If the activity is pending, it is
    * auto-invoked first (pending → active) so callers don't have to know
    * the lifecycle. Cascades auto-transitions and propagates to ancestors
    * after the action commits.
@@ -3705,13 +3819,13 @@ const workflow = {
       client,
       tag,
       instanceId,
-      task,
+      activity,
       action,
       params,
       idempotent,
       resourceClients
     } = args, { access, actor, clientForGdr } = await resolveOperationContext(args), clock = args.clock ?? wallClock, before = await reload(client, instanceId, tag);
-    return findOpenStageEntry(before)?.tasks.find((t) => t.name === task) === void 0 && idempotent === !0 ? { instance: before, cascaded: 0, fired: !1 } : dispatchGatedWrite({
+    return findOpenStageEntry(before)?.activities.find((t) => t.name === activity) === void 0 && idempotent === !0 ? { instance: before, cascaded: 0, fired: !1 } : dispatchGatedWrite({
       client,
       tag,
       instanceId,
@@ -3721,10 +3835,10 @@ const workflow = {
       clock,
       before,
       ...resourceClients !== void 0 ? { resourceClients } : {},
-      apply: (instance, evaluation) => (assertActionAllowed(evaluation, task, action), applyAction({
+      apply: (instance, evaluation) => (assertActionAllowed(evaluation, activity, action), applyAction({
         client,
         instance,
-        task,
+        activity,
         action,
         actor,
         ...access.grants !== void 0 ? { grants: access.grants } : {},
@@ -3805,7 +3919,7 @@ const workflow = {
    * Re-evaluate auto-transitions and resolve due waits until stable.
    *
    * Used by the runtime after any event that might affect the workflow
-   * but isn't itself a task action: a subject doc was patched, a sibling
+   * but isn't itself an activity action: a subject doc was patched, a sibling
    * workflow completed, the clock crossed a `completeWhen` deadline, etc.
    * The runtime doesn't need to know what changed — it just nudges
    * affected instances and the engine re-evaluates.
@@ -3915,8 +4029,8 @@ const workflow = {
    * declared by a `doc.ref` / `doc.refs` entry in scope), then
    * evaluates the supplied GROQ in groq-js against that dataset. The
    * rendered scope is auto-bound: `$self`, `$fields`, `$parent`,
-   * `$ancestors`, `$stage`, `$now`, `$effects`, `$tasks`,
-   * `$allTasksDone`, `$anyTaskFailed` — ids in GDR URI form to match
+   * `$ancestors`, `$stage`, `$now`, `$effects`, `$activities`,
+   * `$allActivitiesDone`, `$anyActivityFailed` — ids in GDR URI form to match
    * the snapshot's keying.
    *
    * Use when an external consumer (a UI, a debug pane, a test) wants
@@ -3969,34 +4083,83 @@ const workflow = {
    * List the actions an actor could fire on an instance's current stage,
    * each flagged `allowed` (with a structured `disabledReason` when not).
    * Projects the instance from the actor's perspective and flattens its
-   * tasks' actions. Returns the evaluation alongside the actions so a
+   * activities' actions. Returns the evaluation alongside the actions so a
    * consumer can read the instance/stage context. Pure read.
    */
   availableActions: async (args) => {
     const evaluation = await evaluateInstance(args);
-    return { evaluation, actions: availableActions(evaluation.currentStage.tasks) };
+    return { evaluation, actions: availableActions(evaluation.currentStage.activities) };
   },
   /**
    * Materialised spawned children of a parent instance.
    *
    * Walks `history` for `spawned` events — the durable
-   * record. (The per-task `spawnedInstances` field on the active stage
+   * record. (The per-activity `spawnedInstances` field on the active stage
    * only exists while that stage is current; history survives.) Strips
    * the GDR URI on each `instanceRef` to a bare `_id`, fetches the
    * instances, drops any that aren't visible to this engine's tag, and
    * returns them sorted by `startedAt` ascending.
    *
-   * Pass `task` to restrict to a single spawning task on the parent.
+   * Pass `activity` to restrict to a single spawning activity on the parent.
    */
   children: async (args) => {
-    const { client, tag, instanceId, task } = args;
+    const { client, tag, instanceId, activity } = args;
     validateTag(tag);
-    const parent = await reload(client, instanceId, tag), isSpawned = (h) => h._type === "spawned", ids = parent.history.filter(isSpawned).filter((h) => task === void 0 || h.task === task).flatMap((h) => bareIdFromSpawnRef(h.instanceRef.id));
+    const parent = await reload(client, instanceId, tag), isSpawned = (h) => h._type === "spawned", ids = parent.history.filter(isSpawned).filter((h) => activity === void 0 || h.activity === activity).flatMap((h) => bareIdFromSpawnRef(h.instanceRef.id));
     return ids.length === 0 ? [] : client.fetch(
       `*[_id in $ids && ${tagScopeFilter()}] | order(startedAt asc)`,
       { ids, tag }
     );
   },
+  /**
+   * Every in-flight instance whose reactive watch-set includes `document` —
+   * the reverse of {@link subscriptionDocumentsForInstance}.
+   *
+   * For a non-reactive, content-change-driven runtime (a Sanity Function, an
+   * Inngest/durable worker, any server) that holds no instances in memory: a
+   * document changed; which instances should it `tick`? The watch-set covers
+   * the instance itself, its ancestors, and the docs named by
+   * `doc.ref` / `doc.refs` / `release.ref` field entries on the workflow scope
+   * **and the current stage** — so a hand-rolled GROQ over `fields[]` gets it
+   * subtly wrong (misses stage-scope refs, `release.ref`, ancestors).
+   *
+   * A coarse GROQ prefilter narrows candidates server-side (in-flight,
+   * tag-scoped, mentioning the doc anywhere in state); the authoritative match
+   * is {@link instanceWatchesDocument}, derived from `collectWatchRefs`, so the
+   * reverse stays in lockstep with the forward set and honours the
+   * open-stage-only rule the prefilter deliberately over-approximates.
+   *
+   * Single-resource: instances always live in the engine's own resource, so
+   * this reads one client (unlike {@link guardsForInstance}, whose guard docs
+   * are scattered across the watched resources). "Routed by resource" applies
+   * to the **subject**: a cross-dataset doc is matched by its full,
+   * resource-qualified GDR URI, never its bare id, so an instance watching
+   * `dataset:A:ds:doc` is not matched by a change to `dataset:B:ds:doc`.
+   *
+   * `document` must be a resource-qualified GDR URI; a bare id is rejected
+   * (it can't be resource-routed and would silently mismatch). Sorted by
+   * `startedAt` ascending.
+   */
+  instancesForDocument: async (args) => {
+    const { client, tag, document } = args;
+    if (validateTag(tag), !isGdrUri(document))
+      throw new Error(
+        `workflow.instancesForDocument: "document" must be a resource-qualified GDR URI (e.g. "dataset:project:dataset:doc-id"); got: ${JSON.stringify(document)}`
+      );
+    const fieldRefsDoc = "count(fields[value.id == $document]) > 0 || count(fields[$document in value[].id]) > 0", query = `*[
+        _type == "${WORKFLOW_INSTANCE_TYPE}" && ${tagScopeFilter()} && !defined(completedAt) && (
+          _id == $bareId ||
+          $document in ancestors[].id ||
+          ${fieldRefsDoc} ||
+          count(stages[${fieldRefsDoc}]) > 0
+        )
+      ] | order(startedAt asc)`;
+    return (await client.fetch(query, {
+      tag,
+      document,
+      bareId: extractDocumentId(document)
+    })).filter((instance) => instanceWatchesDocument(instance, document));
+  },
   /**
    * Permission helpers — Sanity ACL grants evaluated against documents
    * via GROQ. Used by `workflow.evaluate` to soft-gate actions when the
@@ -4050,10 +4213,13 @@ function walkEffectNames(def, visit) {
     for (const e of effects ?? []) visit(e.name, location);
   };
   for (const stage of def.stages ?? []) {
-    for (const t of stage.tasks ?? []) {
-      visitEffects(t.effects, `stage[${stage.name}].task[${t.name}].effects`);
+    for (const t of stage.activities ?? []) {
+      visitEffects(t.effects, `stage[${stage.name}].activity[${t.name}].effects`);
       for (const a of t.actions ?? [])
-        visitEffects(a.effects, `stage[${stage.name}].task[${t.name}].action[${a.name}].effects`);
+        visitEffects(
+          a.effects,
+          `stage[${stage.name}].activity[${t.name}].action[${a.name}].effects`
+        );
     }
     for (const tr of stage.transitions ?? [])
       visitEffects(tr.effects, `stage[${stage.name}].transition[${tr.name}].effects`);
@@ -4069,7 +4235,7 @@ async function drainEffectsInternal(args) {
     effectHandlers,
     missingHandler,
     logger
-  } = args, drainerActor = args.access?.actor ?? { kind: "system", id: "engine.drainEffects" }, completionAccess = {
+  } = args, routeGdr = buildClientForGdr(client, resourceClients), clientFor = (ref) => routeGdr(parseGdr(typeof ref == "string" ? ref : ref.id)), drainerActor = args.access?.actor ?? engineSystemActor("drainEffects"), completionAccess = {
     actor: drainerActor,
     ...args.access?.grants !== void 0 ? { grants: args.access.grants } : {}
   };
@@ -4088,6 +4254,7 @@ async function drainEffectsInternal(args) {
     if (!await claimPendingEffect(client, before, candidate._key, drainerActor)) continue;
     const { outputs, dispatchError } = await dispatchEffect(handler, candidate, {
       client,
+      clientFor,
       instanceId,
       logger
     });
@@ -4142,6 +4309,7 @@ async function dispatchEffect(handler, candidate, ctx) {
   try {
     const result = await handler(candidate.params, {
       client: ctx.client,
+      clientFor: ctx.clientFor,
       instanceId: ctx.instanceId,
       effectKey: candidate._key,
       log: (message, extra) => ctx.logger(`effect.${candidate.name}`).info(message, extra)
@@ -4230,13 +4398,13 @@ function createInstanceSession(args) {
         return instance = await reload(client, instance._id, tag), { instance, cascaded, fired: cascaded > 0 };
       });
     },
-    fireAction({ task, action, params }) {
+    fireAction({ activity, action, params }) {
       return commit(async (actor, held) => {
-        assertActionAllowed(await evaluateWith(held, heldGuards), task, action);
+        assertActionAllowed(await evaluateWith(held, heldGuards), activity, action);
         const { grants } = await access(), ranOps = await applyAction({
           client,
           instance,
-          task,
+          activity,
           action,
           actor,
           clientForGdr,
@@ -4343,13 +4511,14 @@ function createEngine(args) {
       definition,
       ...resourceClients !== void 0 ? { resourceClients } : {}
     }),
-    children: ({ instanceId, task }) => workflow.children({
+    children: ({ instanceId, activity }) => workflow.children({
       client,
       tag,
       workflowResource,
       instanceId,
-      ...task !== void 0 ? { task } : {}
+      ...activity !== void 0 ? { activity } : {}
     }),
+    instancesForDocument: ({ document }) => workflow.instancesForDocument({ client, tag, workflowResource, document }),
     query: ({ groq, params }) => workflow.query({
       client,
       tag,
@@ -4395,33 +4564,25 @@ function createEngine(args) {
     })
   };
 }
-function docIdFor(def, target) {
-  return definitionDocId(target.workflowResource, target.tag, def.name, def.version);
-}
-function diffStatus(existing, expected) {
-  return existing === void 0 ? "create" : isDefinitionUnchanged(existing, expected) ? "unchanged" : "update";
-}
-function diffEntry(def, existingRaw, target) {
-  const docId = docIdFor(def, target), expected = {
-    ...def,
-    _id: docId,
-    _type: schema.WORKFLOW_DEFINITION_TYPE,
-    tag: target.tag
-  }, status = diffStatus(existingRaw, expected), existing = existingRaw ? stripSystemFields(existingRaw) : void 0;
+function diffEntry(def, latestRaw, target) {
+  const plan = planDefinitionDeploy(def, asLatest(latestRaw), target), existing = latestRaw ? stripSystemFields(latestRaw) : void 0;
   return {
     name: def.name,
-    version: def.version,
-    status,
-    docId,
-    expected,
+    version: plan.version,
+    status: plan.status,
+    docId: plan.docId,
+    expected: plan.document,
     ...existing !== void 0 ? { existing } : {}
   };
 }
+function asLatest(raw) {
+  return raw === void 0 ? void 0 : { version: typeof raw.version == "number" ? raw.version : 0, ...typeof raw.contentHash == "string" ? { contentHash: raw.contentHash } : {} };
+}
 async function computeDiffEntries(client, defs, target) {
   const entries = [];
   for (const def of defs) {
-    const existingRaw = await client.getDocument(docIdFor(def, target)) ?? void 0;
-    entries.push(diffEntry(def, existingRaw, target));
+    const latest = await loadLatestDeployed(client, def.name, target.tag);
+    entries.push(diffEntry(def, latest, target));
   }
   return entries;
 }
@@ -4434,17 +4595,17 @@ const HISTORY_DISPLAY = {
     title: "Stage exited",
     description: "The instance left a stage on the way to the next one."
   },
-  taskActivated: {
-    title: "Task activated",
-    description: "A task flipped from `pending` to `active` and its onEnter effects queued."
+  activityActivated: {
+    title: "Activity activated",
+    description: "An activity flipped from `pending` to `active` and its onEnter effects queued."
   },
-  taskStatusChanged: {
-    title: "Task status changed",
-    description: "An action or op flipped a task's status (active \u2192 done / skipped / failed)."
+  activityStatusChanged: {
+    title: "Activity status changed",
+    description: "An action or op flipped an activity's status (active \u2192 done / skipped / failed)."
   },
   actionFired: {
     title: "Action fired",
-    description: "An action was invoked against a task \u2014 ops ran, status may have flipped, effects queued."
+    description: "An action was invoked against an activity \u2014 ops ran, status may have flipped, effects queued."
   },
   transitionFired: {
     title: "Transition fired",
@@ -4460,7 +4621,7 @@ const HISTORY_DISPLAY = {
   },
   spawned: {
     title: "Spawned child",
-    description: "A task's `subworkflows` declaration spawned a child workflow instance."
+    description: "An activity's `subworkflows` declaration spawned a child workflow instance."
   },
   aborted: {
     title: "Instance aborted",
@@ -4469,6 +4630,10 @@ const HISTORY_DISPLAY = {
   opApplied: {
     title: "Op applied",
     description: "An inline field-mutation op (field.set / field.append / status.set / etc.) ran during an action commit."
+  },
+  fieldQueryDiscarded: {
+    title: "Query result discarded",
+    description: "A query-sourced field's GROQ result didn't fit the field's declared kind, so it was discarded and the field fell back to its default."
   }
 }, FIELD_SLOT_DISPLAY = {
   "doc.ref": {
@@ -4483,50 +4648,58 @@ const HISTORY_DISPLAY = {
     title: "Content Release reference",
     description: "GDR pointer at a Content Release system doc, carrying the release name the engine derives the instance's read perspective from."
   },
-  query: {
-    title: "Query result",
-    description: "Snapshot of a GROQ projection captured at entry-resolve time; resolvedAt is stamped on the value."
-  },
-  "value.string": {
+  string: {
     title: "String value",
-    description: "Free-form string entry."
+    description: "Free-form single-line string entry."
   },
-  "value.url": {
-    title: "URL value",
-    description: "Validated URL entry."
+  text: {
+    title: "Text value",
+    description: "Free-form multiline string entry."
   },
-  "value.number": {
+  number: {
     title: "Number value",
     description: "Numeric entry."
   },
-  "value.boolean": {
+  boolean: {
     title: "Boolean value",
     description: "True/false entry."
   },
-  "value.dateTime": {
+  date: {
+    title: "Date value",
+    description: "Date-only (YYYY-MM-DD) entry, no time component."
+  },
+  datetime: {
     title: "Date / time value",
-    description: "ISO-timestamp entry."
+    description: "ISO-8601 timestamp entry."
   },
-  "value.actor": {
-    title: "Actor value",
-    description: "A typed (user|ai|system) actor identity."
+  url: {
+    title: "URL value",
+    description: "Validated URL entry."
   },
-  checklist: {
-    title: "Checklist",
-    description: "Append-only list of checkable items; ops add/update/remove entries."
+  actor: {
+    title: "Actor value",
+    description: "A typed (user|ai|system) actor identity \u2014 a concrete principal."
   },
-  notes: {
-    title: "Notes log",
-    description: "Append-only structured-note log (signoffs, comments, audit rows)."
+  assignee: {
+    title: "Assignee",
+    description: "A single typed (user|role) assignee \u2014 who is expected/responsible."
   },
   assignees: {
     title: "Assignees",
     description: "Ordered list of typed (user|role) assignees."
+  },
+  object: {
+    title: "Object",
+    description: "An object with named sub-fields; the value is keyed by sub-field name."
+  },
+  array: {
+    title: "Array",
+    description: "An array of objects shaped by the declared `of` sub-fields; ops add/update/remove rows."
   }
 }, OP_DISPLAY = {
   "field.set": {
     title: "Set field entry",
-    description: "Overwrite a field entry's value with a resolved Source."
+    description: "Overwrite a field entry's value with a resolved value expression."
   },
   "field.unset": {
     title: "Unset field entry",
@@ -4534,7 +4707,7 @@ const HISTORY_DISPLAY = {
   },
   "field.append": {
     title: "Append to field entry",
-    description: "Push a resolved item onto an array-kind entry (notes, checklist, assignees, refs)."
+    description: "Push a resolved item onto an array-kind entry (array, assignees, doc.refs)."
   },
   "field.updateWhere": {
     title: "Update matching rows",
@@ -4545,8 +4718,8 @@ const HISTORY_DISPLAY = {
     description: "Drop rows of an array-kind entry that match the predicate."
   },
   "status.set": {
-    title: "Set task status",
-    description: "Flip a task's status explicitly (the action-level `status:` sugar desugars to this)."
+    title: "Set activity status",
+    description: "Flip an activity's status explicitly (the action-level `status:` sugar desugars to this)."
   }
 }, EFFECTS_CONTEXT_DISPLAY = {
   "effectsContext.string": {
@@ -4586,6 +4759,35 @@ const HISTORY_DISPLAY = {
     title: "Workflow instance",
     description: "A running (or finished) workflow against its declared fields."
   }
+}, ACTIVITY_KIND_DISPLAY = {
+  user: {
+    title: "User activity",
+    description: "A person acts via the app \u2014 renders action buttons ranked by outcome."
+  },
+  service: {
+    title: "Service activity",
+    description: "An automated system or effect does the work \u2014 renders effect drain status."
+  },
+  script: {
+    title: "Script activity",
+    description: "The engine runs a step inline and resolves on activation \u2014 an audit row."
+  },
+  manual: {
+    title: "Manual activity",
+    description: "Work done off-system, acknowledged by a person or verified by a predicate \u2014 renders an instruction card with a deep-link."
+  },
+  receive: {
+    title: "Receive activity",
+    description: 'No actor; the engine waits on a condition \u2014 renders "waiting until \u2026", no buttons.'
+  }
+}, DRIVER_KIND_DISPLAY = {
+  person: { title: "Person", description: "A human fired this action." },
+  agent: { title: "Agent", description: "An AI agent fired this action." },
+  service: { title: "Service", description: "An external system or Function fired this action." },
+  engine: {
+    title: "Engine",
+    description: "The workflow engine itself drove this \u2014 a gate, machine step, or housekeeping."
+  }
 }, DISPLAY = {
   ...HISTORY_DISPLAY,
   ...FIELD_SLOT_DISPLAY,
@@ -4600,8 +4802,11 @@ function displayDescription(typeKey) {
   if (typeKey)
     return DISPLAY[typeKey]?.description;
 }
+exports.ACTIVITY_KINDS = schema.ACTIVITY_KINDS;
+exports.DRIVER_KINDS = schema.DRIVER_KINDS;
 exports.WORKFLOW_DEFINITION_TYPE = schema.WORKFLOW_DEFINITION_TYPE;
 exports.isStartableDefinition = schema.isStartableDefinition;
+exports.ACTIVITY_KIND_DISPLAY = ACTIVITY_KIND_DISPLAY;
 exports.AUTHORING_DISPLAY = AUTHORING_DISPLAY;
 exports.ActionDisabledError = ActionDisabledError;
 exports.ActionParamsInvalidError = ActionParamsInvalidError;
@@ -4610,6 +4815,7 @@ exports.ConcurrentEditFieldError = ConcurrentEditFieldError;
 exports.ConcurrentFireActionError = ConcurrentFireActionError;
 exports.DEFAULT_CONTENT_PERSPECTIVE = DEFAULT_CONTENT_PERSPECTIVE;
 exports.DISPLAY = DISPLAY;
+exports.DRIVER_KIND_DISPLAY = DRIVER_KIND_DISPLAY;
 exports.EFFECTS_CONTEXT_DISPLAY = EFFECTS_CONTEXT_DISPLAY;
 exports.EditFieldDeniedError = EditFieldDeniedError;
 exports.FIELD_SLOT_DISPLAY = FIELD_SLOT_DISPLAY;
@@ -4625,6 +4831,7 @@ exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;
 exports.WorkflowStateDivergedError = WorkflowStateDivergedError;
 exports.abortReason = abortReason;
 exports.actionVerdict = actionVerdict;
+exports.activityKind = activityKind;
 exports.availableActions = availableActions;
 exports.buildSnapshot = buildSnapshot;
 exports.compileGuard = compileGuard;
@@ -4635,11 +4842,13 @@ exports.datasetResourceParts = datasetResourceParts;
 exports.defaultLoggerFactory = defaultLoggerFactory;
 exports.denyingGuards = denyingGuards;
 exports.deployStageGuards = deployStageGuards;
+exports.deriveActivityKind = deriveActivityKind;
 exports.diagnoseInputFromEvaluation = diagnoseInputFromEvaluation;
 exports.diagnoseInstance = diagnoseInstance;
 exports.diffEntry = diffEntry;
 exports.displayDescription = displayDescription;
 exports.displayTitle = displayTitle;
+exports.driverKind = driverKind;
 exports.effectsContextMap = effectsContextMap;
 exports.evaluateFromSnapshot = evaluateFromSnapshot;
 exports.evaluateMutationGuard = evaluateMutationGuard;
@@ -4651,8 +4860,9 @@ exports.guardMatches = guardMatches;
 exports.guardsForDefinition = guardsForDefinition;
 exports.guardsForInstance = guardsForInstance;
 exports.guardsForResource = guardsForResource;
+exports.hashDefinitionContent = hashDefinitionContent;
 exports.instanceGuardQuery = instanceGuardQuery;
-exports.isDefinitionUnchanged = isDefinitionUnchanged;
+exports.instanceWatchesDocument = instanceWatchesDocument;
 exports.isGdr = isGdr;
 exports.isTerminalStage = isTerminalStage;
 exports.lakeGuardId = lakeGuardId;