@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/dist/modules/staff/commands/timesheets-tasks.js

@@ -0,0 +1,834 @@
+import { z } from "zod";
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import { CrudHttpError } from "@open-mercato/shared/lib/crud/errors";
+import { enforceCommandOptimisticLockWithGuards } from "@open-mercato/shared/lib/crud/optimistic-lock-command";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
+import { findOneWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { buildChanges, emitCrudSideEffects, emitCrudUndoSideEffects } from "@open-mercato/shared/lib/commands/helpers";
+import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
+import { StaffTeamMember, StaffTimeProject, StaffTimeTask, StaffTimeTaskStatus } from "../data/entities.js";
+import {
+  staffTimeTaskCreateSchema,
+  staffTimeTaskStatusChangeSchema,
+  staffTimeTaskUpdateSchema
+} from "../data/validators.js";
+import { emitStaffEvent } from "../events.js";
+import { nextStatusPosition } from "../lib/timesheets-tasks/statusPositions.js";
+import {
+  allocateTaskReference,
+  isTaskReferenceConflict,
+  withTaskReferenceRetry
+} from "../lib/timesheets-tasks/taskReference.js";
+import {
+  SUBTASK_DEPTH_EXCEEDED_CODE,
+  planTaskSoftDelete,
+  rejectTaskParent
+} from "../lib/timesheets-tasks/taskHierarchy.js";
+import {
+  applyScopeToWhere,
+  commandActorScope,
+  commandInputScope,
+  ensureOrganizationScope,
+  ensureTenantScope,
+  extractUndoPayload,
+  scopeForDecryption,
+  scopedStaffSnapshotWhere,
+  staffSnapshotScopeFromContext,
+  staffSnapshotScopeFromSnapshot
+} from "./shared.js";
+const staffTimeTaskCommandIds = {
+  create: "staff.timesheets.tasks.create",
+  update: "staff.timesheets.tasks.update",
+  delete: "staff.timesheets.tasks.delete",
+  statusChange: "staff.timesheets.tasks.status_change"
+};
+const STAFF_TIME_TASK_RESOURCE_KIND = "staff.timesheets.time_task";
+const TASK_DEPTH_EXCEEDED_CODE = SUBTASK_DEPTH_EXCEEDED_CODE;
+const TASK_PARENT_SELF_CODE = "task_parent_self";
+const TASK_PARENT_PROJECT_MISMATCH_CODE = "task_parent_project_mismatch";
+const TASK_PROJECT_MOVE_UNSUPPORTED_CODE = "task_project_move_unsupported";
+const TASK_STATUS_MISSING_CODE = "task_status_missing";
+const TASK_REFERENCE_CONFLICT_CODE = "task_reference_conflict";
+const logger = createLogger("staff").child({ component: "commands/timesheets-tasks" });
+const taskCrudIndexer = {
+  entityType: "staff:staff_time_task"
+};
+const taskCrudEvents = {
+  module: "staff",
+  entity: "timesheets.time_task",
+  persistent: true,
+  buildPayload: (ctx) => ({
+    id: ctx.identifiers.id,
+    organizationId: ctx.identifiers.organizationId,
+    tenantId: ctx.identifiers.tenantId
+  })
+};
+const TASK_LIST_CACHE_RESOURCE = `${taskCrudEvents.module}.${taskCrudEvents.entity}`;
+const DIFFED_FIELDS = [
+  "parentTaskId",
+  "taskStatusId",
+  "title",
+  "description",
+  "assigneeStaffMemberId",
+  "position",
+  "closedAt"
+];
+function toSnapshot(task) {
+  return {
+    id: task.id,
+    tenantId: task.tenantId,
+    organizationId: task.organizationId,
+    timeProjectId: task.timeProjectId,
+    parentTaskId: task.parentTaskId ?? null,
+    taskStatusId: task.taskStatusId,
+    sequenceNumber: task.sequenceNumber,
+    reference: task.reference,
+    title: task.title,
+    description: task.description ?? null,
+    assigneeStaffMemberId: task.assigneeStaffMemberId ?? null,
+    position: task.position,
+    createdByUserId: task.createdByUserId ?? null,
+    closedAt: task.closedAt ? task.closedAt.toISOString() : null,
+    deletedAt: task.deletedAt ? task.deletedAt.toISOString() : null
+  };
+}
+function snapshotScopeWhere(scope) {
+  const where = {};
+  if (scope?.tenantId) where.tenantId = scope.tenantId;
+  if (scope?.organizationId) where.organizationId = scope.organizationId;
+  return where;
+}
+async function loadTaskSnapshot(em, id, scope) {
+  const task = await em.findOne(StaffTimeTask, scopedStaffSnapshotWhere(id, scope));
+  return task ? toSnapshot(task) : null;
+}
+async function loadChildSnapshots(em, parentTaskId, scope) {
+  const children = await em.find(StaffTimeTask, {
+    parentTaskId,
+    deletedAt: null,
+    ...snapshotScopeWhere(scope)
+  });
+  return children.map(toSnapshot);
+}
+function notFoundError(translate) {
+  return new CrudHttpError(404, {
+    error: translate("staff.time_tracking.tasks.errors.notFound", "Task not found or not accessible.")
+  });
+}
+function projectNotFoundError(translate) {
+  const message = translate("staff.timesheets.errors.projectNotFound", "Time project not found or not accessible.");
+  return new CrudHttpError(422, { error: message, fieldErrors: { timeProjectId: message } });
+}
+function statusNotFoundError(translate) {
+  const message = translate(
+    "staff.time_tracking.tasks.errors.statusNotFound",
+    "That column does not belong to this project."
+  );
+  return new CrudHttpError(422, { error: message, fieldErrors: { taskStatusId: message } });
+}
+function statusMissingError(translate) {
+  return new CrudHttpError(422, {
+    code: TASK_STATUS_MISSING_CODE,
+    error: translate(
+      "staff.time_tracking.tasks.errors.statusMissing",
+      "This project has no columns yet, so a task cannot be placed on its board."
+    )
+  });
+}
+function parentNotFoundError(translate) {
+  const message = translate(
+    "staff.time_tracking.tasks.errors.parentNotFound",
+    "Parent task not found or not accessible."
+  );
+  return new CrudHttpError(422, { error: message, fieldErrors: { parentTaskId: message } });
+}
+function assigneeNotFoundError(translate) {
+  const message = translate(
+    "staff.timesheets.errors.staffMemberNotFound",
+    "Staff member not found or not accessible."
+  );
+  return new CrudHttpError(422, { error: message, fieldErrors: { assigneeStaffMemberId: message } });
+}
+function parentRejectionError(translate, rejection) {
+  if (rejection === "self_parent") {
+    const message2 = translate(
+      "staff.time_tracking.tasks.errors.parentSelf",
+      "A task cannot be its own subtask."
+    );
+    return new CrudHttpError(400, {
+      code: TASK_PARENT_SELF_CODE,
+      error: message2,
+      fieldErrors: { parentTaskId: message2 }
+    });
+  }
+  if (rejection === "parent_project_mismatch") {
+    const message2 = translate(
+      "staff.time_tracking.tasks.errors.parentProjectMismatch",
+      "A subtask must stay in the same project as its parent."
+    );
+    return new CrudHttpError(422, {
+      code: TASK_PARENT_PROJECT_MISMATCH_CODE,
+      error: message2,
+      fieldErrors: { parentTaskId: message2 }
+    });
+  }
+  const message = translate(
+    "staff.time_tracking.tasks.errors.subtaskDepthExceeded",
+    "Subtasks are one level deep. A subtask cannot have subtasks of its own."
+  );
+  return new CrudHttpError(400, {
+    code: TASK_DEPTH_EXCEEDED_CODE,
+    error: message,
+    fieldErrors: { parentTaskId: message }
+  });
+}
+function referenceConflictError(translate) {
+  return new CrudHttpError(409, {
+    code: TASK_REFERENCE_CONFLICT_CODE,
+    error: translate(
+      "staff.time_tracking.tasks.errors.referenceConflict",
+      "Could not allocate a task number right now. Try again."
+    )
+  });
+}
+async function requireProject(em, timeProjectId, scope, translate) {
+  const project = await em.findOne(
+    StaffTimeProject,
+    applyScopeToWhere({ id: timeProjectId, deletedAt: null }, scope)
+  );
+  if (!project) throw projectNotFoundError(translate);
+  return project;
+}
+async function resolveTaskStatus(em, timeProjectId, requestedStatusId, scope, translate) {
+  if (requestedStatusId) {
+    const status = await em.findOne(
+      StaffTimeTaskStatus,
+      applyScopeToWhere({ id: requestedStatusId, timeProjectId, deletedAt: null }, scope)
+    );
+    if (!status) throw statusNotFoundError(translate);
+    return status;
+  }
+  const board = await em.find(
+    StaffTimeTaskStatus,
+    applyScopeToWhere({ timeProjectId, deletedAt: null }, scope)
+  );
+  if (board.length === 0) throw statusMissingError(translate);
+  const ordered = [...board].sort((left, right) => left.position - right.position);
+  return ordered.find((status) => status.isDefault) ?? ordered[0];
+}
+async function requireParentTask(em, parentTaskId, scope, translate) {
+  const parent = await em.findOne(
+    StaffTimeTask,
+    applyScopeToWhere({ id: parentTaskId, deletedAt: null }, scope)
+  );
+  if (!parent) throw parentNotFoundError(translate);
+  return parent;
+}
+async function resolveStaffMemberIdForUser(em, userId, scope) {
+  if (!userId) return null;
+  const member = await findOneWithDecryption(
+    em,
+    StaffTeamMember,
+    applyScopeToWhere({ userId, deletedAt: null }, scope),
+    void 0,
+    scopeForDecryption(scope)
+  );
+  return member?.id ?? null;
+}
+async function requireStaffMember(em, staffMemberId, scope, translate) {
+  const member = await em.findOne(
+    StaffTeamMember,
+    applyScopeToWhere({ id: staffMemberId, deletedAt: null }, scope)
+  );
+  if (!member) throw assigneeNotFoundError(translate);
+  return member.id;
+}
+async function nextTaskPosition(em, timeProjectId, taskStatusId, scope) {
+  const siblings = await em.find(
+    StaffTimeTask,
+    applyScopeToWhere({ timeProjectId, taskStatusId, deletedAt: null }, scope)
+  );
+  return nextStatusPosition(siblings.map((task) => task.position));
+}
+async function readHighestSequenceNumber(em, timeProjectId, scope) {
+  const tasks = await em.find(StaffTimeTask, applyScopeToWhere({ timeProjectId }, scope));
+  return tasks.reduce((highest, task) => Math.max(highest, task.sequenceNumber ?? 0), 0);
+}
+function assertNoProjectMove(rawInput, task, translate) {
+  if (!rawInput || typeof rawInput !== "object") return;
+  const requested = rawInput.timeProjectId;
+  if (requested === void 0 || requested === null) return;
+  if (typeof requested === "string" && requested === task.timeProjectId) return;
+  const message = translate(
+    "staff.time_tracking.tasks.errors.projectMoveUnsupported",
+    "A task cannot be moved to another project. Create it in the target project instead."
+  );
+  throw new CrudHttpError(400, {
+    code: TASK_PROJECT_MOVE_UNSUPPORTED_CODE,
+    error: message,
+    fieldErrors: { timeProjectId: message }
+  });
+}
+function applyStatusToTask(task, status, now) {
+  task.taskStatusId = status.id;
+  if (status.isDone) {
+    if (!task.closedAt) task.closedAt = now;
+  } else {
+    task.closedAt = null;
+  }
+}
+function actorUserId(ctx) {
+  return typeof ctx.auth?.sub === "string" ? ctx.auth.sub : null;
+}
+const createTaskCommand = {
+  id: staffTimeTaskCommandIds.create,
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTaskCreateSchema.parse(rawInput);
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const scope = commandInputScope(ctx, parsed.tenantId, parsed.organizationId);
+    const { translate } = await resolveTranslations();
+    const baseEm = ctx.container.resolve("em");
+    const createdByUserId = actorUserId(ctx);
+    let record;
+    try {
+      record = await withTaskReferenceRetry(async () => {
+        const em = baseEm.fork();
+        let created = null;
+        let plan = null;
+        await withAtomicFlush(
+          em,
+          [
+            async () => {
+              const project = await requireProject(em, parsed.timeProjectId, scope, translate);
+              const status = await resolveTaskStatus(em, parsed.timeProjectId, parsed.taskStatusId, scope, translate);
+              let parentTaskId = null;
+              if (parsed.parentTaskId) {
+                const parent = await requireParentTask(em, parsed.parentTaskId, scope, translate);
+                const rejection = rejectTaskParent(parent, { timeProjectId: parsed.timeProjectId });
+                if (rejection) throw parentRejectionError(translate, rejection);
+                parentTaskId = parent.id;
+              }
+              const assigneeStaffMemberId = parsed.assigneeStaffMemberId ? await requireStaffMember(em, parsed.assigneeStaffMemberId, scope, translate) : await resolveStaffMemberIdForUser(em, createdByUserId, scope);
+              plan = {
+                project,
+                status,
+                parentTaskId,
+                assigneeStaffMemberId,
+                position: parsed.position ?? await nextTaskPosition(em, parsed.timeProjectId, status.id, scope),
+                highestSequenceNumber: await readHighestSequenceNumber(em, parsed.timeProjectId, scope)
+              };
+            },
+            () => {
+              if (!plan) throw notFoundError(translate);
+              const now = /* @__PURE__ */ new Date();
+              const allocation = allocateTaskReference(plan.project.code, plan.highestSequenceNumber);
+              created = em.create(StaffTimeTask, {
+                tenantId: parsed.tenantId,
+                organizationId: parsed.organizationId,
+                timeProjectId: parsed.timeProjectId,
+                parentTaskId: plan.parentTaskId,
+                taskStatusId: plan.status.id,
+                sequenceNumber: allocation.sequenceNumber,
+                reference: allocation.reference,
+                title: parsed.title,
+                description: parsed.description ?? null,
+                assigneeStaffMemberId: plan.assigneeStaffMemberId,
+                position: plan.position,
+                createdByUserId,
+                closedAt: plan.status.isDone ? now : null,
+                createdAt: now,
+                updatedAt: now,
+                deletedAt: null
+              });
+              em.persist(created);
+            }
+          ],
+          { transaction: true, label: staffTimeTaskCommandIds.create }
+        );
+        if (!created) throw notFoundError(translate);
+        return created;
+      });
+    } catch (err) {
+      if (isTaskReferenceConflict(err)) throw referenceConflictError(translate);
+      throw err;
+    }
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "created",
+      entity: record,
+      identifiers: { id: record.id, organizationId: record.organizationId, tenantId: record.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+    return { taskId: record.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTaskSnapshot(em, result.taskId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    return { snapshot };
+  },
+  buildLog: async ({ result, ctx }) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTaskSnapshot(em, result.taskId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tasks.create", "Create task"),
+      resourceKind: "staff.timesheets.task",
+      resourceId: snapshot.id,
+      tenantId: snapshot.tenantId,
+      organizationId: snapshot.organizationId,
+      snapshotAfter: snapshot,
+      payload: {
+        undo: { after: snapshot }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = ctx.container.resolve("em").fork();
+    const task = await em.findOne(StaffTimeTask, scopedStaffSnapshotWhere(after.id, staffSnapshotScopeFromSnapshot(after)));
+    if (!task) return;
+    task.deletedAt = /* @__PURE__ */ new Date();
+    task.updatedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "deleted",
+      entity: task,
+      identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+  }
+};
+const updateTaskCommand = {
+  id: staffTimeTaskCommandIds.update,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTaskUpdateSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const before = await loadTaskSnapshot(em, parsed.data.id, staffSnapshotScopeFromContext(ctx));
+    if (!before) return {};
+    return { before: { snapshot: before } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTaskUpdateSchema.parse(rawInput);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const task = await em.findOne(
+      StaffTimeTask,
+      applyScopeToWhere({ id: parsed.id, deletedAt: null }, scope)
+    );
+    if (!task) throw notFoundError(translate);
+    ensureTenantScope(ctx, task.tenantId);
+    ensureOrganizationScope(ctx, task.organizationId);
+    assertNoProjectMove(rawInput, task, translate);
+    let targetStatus = null;
+    let targetParentTaskId;
+    let targetAssigneeStaffMemberId;
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          if (parsed.taskStatusId !== void 0) {
+            targetStatus = await resolveTaskStatus(em, task.timeProjectId, parsed.taskStatusId, scope, translate);
+          }
+          if (parsed.parentTaskId !== void 0) {
+            if (parsed.parentTaskId === null) {
+              targetParentTaskId = null;
+            } else {
+              const parent = await requireParentTask(em, parsed.parentTaskId, scope, translate);
+              const childCount = await em.count(
+                StaffTimeTask,
+                applyScopeToWhere({ parentTaskId: task.id, deletedAt: null }, scope)
+              );
+              const rejection = rejectTaskParent(parent, {
+                id: task.id,
+                timeProjectId: task.timeProjectId,
+                childCount
+              });
+              if (rejection) throw parentRejectionError(translate, rejection);
+              targetParentTaskId = parent.id;
+            }
+          }
+          if (parsed.assigneeStaffMemberId !== void 0) {
+            targetAssigneeStaffMemberId = parsed.assigneeStaffMemberId ? await requireStaffMember(em, parsed.assigneeStaffMemberId, scope, translate) : null;
+          }
+        },
+        () => {
+          const now = /* @__PURE__ */ new Date();
+          if (parsed.title !== void 0) task.title = parsed.title;
+          if (parsed.description !== void 0) task.description = parsed.description ?? null;
+          if (parsed.position !== void 0) task.position = parsed.position;
+          if (targetParentTaskId !== void 0) task.parentTaskId = targetParentTaskId;
+          if (targetAssigneeStaffMemberId !== void 0) task.assigneeStaffMemberId = targetAssigneeStaffMemberId;
+          if (targetStatus) applyStatusToTask(task, targetStatus, now);
+          task.updatedAt = now;
+        }
+      ],
+      { transaction: true, label: staffTimeTaskCommandIds.update }
+    );
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: task,
+      identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+    return { taskId: task.id };
+  },
+  buildLog: async ({ snapshots, ctx }) => {
+    const before = snapshots.before?.snapshot;
+    if (!before) return null;
+    const em = ctx.container.resolve("em").fork();
+    const after = await loadTaskSnapshot(em, before.id, staffSnapshotScopeFromSnapshot(before));
+    if (!after) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tasks.update", "Update task"),
+      resourceKind: "staff.timesheets.task",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      changes: buildChanges(
+        before,
+        after,
+        [...DIFFED_FIELDS]
+      ),
+      payload: {
+        undo: { before, after }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = ctx.container.resolve("em").fork();
+    const task = await em.findOne(
+      StaffTimeTask,
+      scopedStaffSnapshotWhere(before.id, staffSnapshotScopeFromSnapshot(before))
+    );
+    if (!task) return;
+    task.parentTaskId = before.parentTaskId;
+    task.taskStatusId = before.taskStatusId;
+    task.title = before.title;
+    task.description = before.description;
+    task.assigneeStaffMemberId = before.assigneeStaffMemberId;
+    task.position = before.position;
+    task.closedAt = before.closedAt ? new Date(before.closedAt) : null;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: task,
+      identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+  }
+};
+const deleteTaskCommand = {
+  id: staffTimeTaskCommandIds.delete,
+  async prepare(input, ctx) {
+    const id = input?.id;
+    if (!id) return {};
+    const em = ctx.container.resolve("em");
+    const scope = staffSnapshotScopeFromContext(ctx);
+    const before = await loadTaskSnapshot(em, id, scope);
+    if (!before) return {};
+    const cascadedChildren = before.parentTaskId ? [] : await loadChildSnapshots(em, before.id, scope);
+    return { before: { snapshot: before, cascadedChildren } };
+  },
+  async execute(input, ctx) {
+    const { translate } = await resolveTranslations();
+    const id = input?.id;
+    if (!id) {
+      throw new CrudHttpError(400, {
+        error: translate("staff.time_tracking.tasks.errors.idRequired", "Task id is required.")
+      });
+    }
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const task = await em.findOne(
+      StaffTimeTask,
+      applyScopeToWhere({ id, deletedAt: null }, scope)
+    );
+    if (!task) throw notFoundError(translate);
+    ensureTenantScope(ctx, task.tenantId);
+    ensureOrganizationScope(ctx, task.organizationId);
+    let children = [];
+    let childIds = [];
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          children = task.parentTaskId ? [] : await em.find(
+            StaffTimeTask,
+            applyScopeToWhere({ parentTaskId: task.id, deletedAt: null }, scope)
+          );
+        },
+        () => {
+          const plan = planTaskSoftDelete(task, children);
+          childIds = plan.childIds;
+          const now = /* @__PURE__ */ new Date();
+          const byId = new Map(children.map((child) => [child.id, child]));
+          task.deletedAt = now;
+          task.updatedAt = now;
+          for (const childId of childIds) {
+            const child = byId.get(childId);
+            if (!child) continue;
+            child.deletedAt = now;
+            child.updatedAt = now;
+          }
+        }
+      ],
+      { transaction: true, label: staffTimeTaskCommandIds.delete }
+    );
+    const dataEngine = ctx.container.resolve("dataEngine");
+    for (const removed of [task, ...children.filter((child) => childIds.includes(child.id))]) {
+      await emitCrudSideEffects({
+        dataEngine,
+        action: "deleted",
+        entity: removed,
+        identifiers: { id: removed.id, organizationId: removed.organizationId, tenantId: removed.tenantId },
+        events: taskCrudEvents,
+        indexer: taskCrudIndexer
+      });
+    }
+    return { taskId: task.id, childIds };
+  },
+  buildLog: async ({ snapshots }) => {
+    const prepared = snapshots.before;
+    const before = prepared?.snapshot;
+    if (!before) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tasks.delete", "Delete task"),
+      resourceKind: "staff.timesheets.task",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      payload: {
+        undo: {
+          before,
+          cascadedChildren: prepared?.cascadedChildren ?? null
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const snapshotScope = staffSnapshotScopeFromSnapshot(before);
+    const em = ctx.container.resolve("em").fork();
+    const ids = [before.id, ...(payload?.cascadedChildren ?? []).map((child) => child.id)];
+    const restored = [];
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          const tasks = await em.find(StaffTimeTask, {
+            id: { $in: ids },
+            ...snapshotScopeWhere(snapshotScope)
+          });
+          restored.push(...tasks);
+        },
+        () => {
+          for (const task of restored) {
+            task.deletedAt = null;
+            task.updatedAt = /* @__PURE__ */ new Date();
+          }
+        }
+      ],
+      { transaction: true, label: `${staffTimeTaskCommandIds.delete}.undo` }
+    );
+    const dataEngine = ctx.container.resolve("dataEngine");
+    for (const task of restored) {
+      await emitCrudUndoSideEffects({
+        dataEngine,
+        action: "created",
+        entity: task,
+        identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+        events: taskCrudEvents,
+        indexer: taskCrudIndexer
+      });
+    }
+  }
+};
+const statusChangeInputSchema = staffTimeTaskStatusChangeSchema.extend({
+  id: z.string().uuid()
+});
+const STATUS_CHANGE_DIFFED_FIELDS = ["taskStatusId", "position", "closedAt"];
+const statusChangeTaskCommand = {
+  id: staffTimeTaskCommandIds.statusChange,
+  async prepare(rawInput, ctx) {
+    const parsed = statusChangeInputSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const before = await loadTaskSnapshot(em, parsed.data.id, staffSnapshotScopeFromContext(ctx));
+    if (!before) return {};
+    return { before: { snapshot: before } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = statusChangeInputSchema.parse(rawInput);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const task = await em.findOne(
+      StaffTimeTask,
+      applyScopeToWhere({ id: parsed.id, deletedAt: null }, scope)
+    );
+    if (!task) throw notFoundError(translate);
+    ensureTenantScope(ctx, task.tenantId);
+    ensureOrganizationScope(ctx, task.organizationId);
+    await enforceCommandOptimisticLockWithGuards(ctx.container, {
+      resourceKind: STAFF_TIME_TASK_RESOURCE_KIND,
+      resourceId: task.id,
+      current: task.updatedAt,
+      request: ctx.request
+    });
+    const previousTaskStatusId = task.taskStatusId;
+    let targetStatus = null;
+    let targetPosition = task.position;
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          targetStatus = await resolveTaskStatus(em, task.timeProjectId, parsed.taskStatusId, scope, translate);
+          targetPosition = parsed.position ?? await nextTaskPosition(em, task.timeProjectId, targetStatus.id, scope);
+        },
+        () => {
+          if (!targetStatus) throw notFoundError(translate);
+          const now = /* @__PURE__ */ new Date();
+          task.position = targetPosition;
+          applyStatusToTask(task, targetStatus, now);
+          task.updatedAt = now;
+        }
+      ],
+      { transaction: true, label: staffTimeTaskCommandIds.statusChange }
+    );
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: task,
+      identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+    const result = {
+      taskId: task.id,
+      timeProjectId: task.timeProjectId,
+      previousTaskStatusId,
+      taskStatusId: task.taskStatusId,
+      position: task.position,
+      closedAt: task.closedAt ? task.closedAt.toISOString() : null,
+      updatedAt: task.updatedAt ? task.updatedAt.toISOString() : null
+    };
+    void emitStaffEvent("staff.timesheets.time_task.status_changed", {
+      id: task.id,
+      tenantId: task.tenantId,
+      organizationId: task.organizationId,
+      ...result
+    }).catch((err) => {
+      logger.error("staff.timesheets emit time_task.status_changed failed", { err });
+    });
+    return result;
+  },
+  buildLog: async ({ snapshots, ctx }) => {
+    const before = snapshots.before?.snapshot;
+    if (!before) return null;
+    const em = ctx.container.resolve("em").fork();
+    const after = await loadTaskSnapshot(em, before.id, staffSnapshotScopeFromSnapshot(before));
+    if (!after) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tasks.statusChange", "Move task"),
+      resourceKind: "staff.timesheets.task",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      // Flushes the cached tasks list the board refetches right after the move,
+      // and again after an undo — the audit resourceKind above names a different
+      // tag. See TASK_LIST_CACHE_RESOURCE.
+      context: { cacheAliases: [TASK_LIST_CACHE_RESOURCE] },
+      snapshotBefore: before,
+      snapshotAfter: after,
+      changes: buildChanges(
+        before,
+        after,
+        [...STATUS_CHANGE_DIFFED_FIELDS]
+      ),
+      payload: {
+        undo: { before, after }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = ctx.container.resolve("em").fork();
+    const task = await em.findOne(
+      StaffTimeTask,
+      scopedStaffSnapshotWhere(before.id, staffSnapshotScopeFromSnapshot(before))
+    );
+    if (!task) return;
+    const previousTaskStatusId = task.taskStatusId;
+    task.taskStatusId = before.taskStatusId;
+    task.position = before.position;
+    task.closedAt = before.closedAt ? new Date(before.closedAt) : null;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: task,
+      identifiers: { id: task.id, organizationId: task.organizationId, tenantId: task.tenantId },
+      events: taskCrudEvents,
+      indexer: taskCrudIndexer
+    });
+    void emitStaffEvent("staff.timesheets.time_task.status_changed", {
+      id: task.id,
+      tenantId: task.tenantId,
+      organizationId: task.organizationId,
+      taskId: task.id,
+      timeProjectId: task.timeProjectId,
+      previousTaskStatusId,
+      taskStatusId: task.taskStatusId,
+      position: task.position,
+      closedAt: task.closedAt ? task.closedAt.toISOString() : null,
+      updatedAt: task.updatedAt ? task.updatedAt.toISOString() : null
+    }).catch((err) => {
+      logger.error("staff.timesheets emit time_task.status_changed failed", { err });
+    });
+  }
+};
+registerCommand(createTaskCommand);
+registerCommand(updateTaskCommand);
+registerCommand(deleteTaskCommand);
+registerCommand(statusChangeTaskCommand);
+export {
+  STAFF_TIME_TASK_RESOURCE_KIND,
+  TASK_DEPTH_EXCEEDED_CODE,
+  TASK_PARENT_PROJECT_MISMATCH_CODE,
+  TASK_PARENT_SELF_CODE,
+  TASK_PROJECT_MOVE_UNSUPPORTED_CODE,
+  TASK_REFERENCE_CONFLICT_CODE,
+  TASK_STATUS_MISSING_CODE,
+  staffTimeTaskCommandIds
+};
+//# sourceMappingURL=timesheets-tasks.js.map