rename(phase 1): CapaKraken → Nexus across code, UI, docs, CI

- @capakraken/* → @nexus/* across 12 packages (root + 11 workspaces),
  1551 import lines migrated via codemod
- User-visible brand strings renamed (emails, page titles, PWA
  manifest, mobile header, MFA backup-codes header, tooltips, signin
  page, invite page, weekly digest, install prompt)
- TOTP issuer "CapaKraken" → "Nexus" (existing secrets still valid;
  re-enrollment relabels them in users' authenticator apps)
- Function rename: assertCapaKrakenDbTarget → assertNexusDbTarget
- LocalStorage migration shim in apps/web/src/app/layout.tsx copies
  capakraken_* → nexus_* on first load (guarded by nexus_migrated_v1
  sentinel; runs once per browser, then never again)
- Service-worker cache name capakraken-v2 → nexus-v2 with one-time
  caches.delete('capakraken-v2') from the same shim
- Email-domain fixtures @capakraken.{dev,app} → @nexus.{dev,app} in
  seed data, e2e specs, SMTP default fallback
- Dockerfile.dev / Dockerfile.prod / all .github/workflows/*.yml
  pnpm --filter @capakraken/* → @nexus/*
- README, CLAUDE.md, LEARNINGS.md, all docs/*.md, .env.example,
  tooling/deploy/.env.production.example brand sweep

Phase 1 deliberately leaves untouched (handled in Phase 3 cutover):
- PostgreSQL DB name "capakraken" and POSTGRES_USER "capakraken"
- Volume names capakraken_pgdata etc.
- Compose project name "capakraken" / "capakraken-prod"
- db-target-guard default expectedDatabase
- env-var CAPAKRAKEN_EXPECTED_DB_NAME
- Container DNS names in docker-compose.ci.yml

Quality gates green: pnpm typecheck (7/7), pnpm test:unit (7/7),
pnpm lint (0 errors), check:exports/imports/architecture all pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

packages/application/src/use-cases/dispo-import/assess-import-readiness.ts

@@ -1,4 +1,4 @@
-import { ImportBatchStatus, type Prisma } from "@capakraken/db";
+import { ImportBatchStatus, type Prisma } from "@nexus/db";
 import { parseDispoChargeabilityWorkbook } from "./parse-chargeability-workbook.js";
 import { parseDispoPlanningWorkbook } from "./parse-dispo-matrix.js";
 import { parseDispoRosterWorkbook } from "./parse-dispo-roster-workbook.js";
@@ -125,18 +125,17 @@ export async function assessDispoImportReadiness(
     planningWorkbook,
     resourceMasterPresent,
     rosterWorkbook,
-  ] =
-    await Promise.all([
-      parseMandatoryDispoReferenceWorkbook(input.referenceWorkbookPath),
-      parseDispoChargeabilityWorkbook(input.chargeabilityWorkbookPath),
-      parseDispoPlanningWorkbook(input.planningWorkbookPath),
-      hasResourceMasterRows(input.referenceWorkbookPath),
-      input.rosterWorkbookPath
-        ? parseDispoRosterWorkbook(input.rosterWorkbookPath, {
+  ] = await Promise.all([
+    parseMandatoryDispoReferenceWorkbook(input.referenceWorkbookPath),
+    parseDispoChargeabilityWorkbook(input.chargeabilityWorkbookPath),
+    parseDispoPlanningWorkbook(input.planningWorkbookPath),
+    hasResourceMasterRows(input.referenceWorkbookPath),
+    input.rosterWorkbookPath
+      ? parseDispoRosterWorkbook(input.rosterWorkbookPath, {
           ...(input.costWorkbookPath ? { costWorkbookPath: input.costWorkbookPath } : {}),
         })
-        : null,
-    ]);
+      : null,
+  ]);
 
   const mergedResources = new Map<string, MergedResourceReadinessRecord>();
   const excludedIds = new Set(rosterWorkbook?.excludedCanonicalExternalIds ?? []);

packages/application/src/use-cases/dispo-import/build-dispo-maps.ts

@@ -1,8 +1,5 @@
-import type { WeekdayAvailability } from "@capakraken/shared";
-import {
-  createWeekdayAvailabilityFromFte,
-  normalizeDispoRoleToken,
-} from "@capakraken/shared";
+import type { WeekdayAvailability } from "@nexus/shared";
+import { createWeekdayAvailabilityFromFte, normalizeDispoRoleToken } from "@nexus/shared";
 import type { TxClient, MergedStagedResource } from "./commit-dispo-batch-types.js";
 import { deriveRoleTokens } from "./shared.js";
 
@@ -24,10 +21,7 @@ function asObject(value: unknown): Record<string, unknown> {
     : {};
 }
 
-function mergeScalar<T>(
-  current: T | null,
-  incoming: T | null | undefined,
-): T | null {
+function mergeScalar<T>(current: T | null, incoming: T | null | undefined): T | null {
   return incoming ?? current;
 }
 
@@ -117,7 +111,10 @@ export function mergeStagedResources(
 
     existing.availability = mergeScalar(existing.availability, row.availability);
     existing.chapter = mergeScalar(existing.chapter, row.chapter);
-    existing.chargeabilityTarget = mergeScalar(existing.chargeabilityTarget, row.chargeabilityTarget);
+    existing.chargeabilityTarget = mergeScalar(
+      existing.chargeabilityTarget,
+      row.chargeabilityTarget,
+    );
     existing.clientUnitName = mergeScalar(existing.clientUnitName, row.clientUnitName);
     existing.countryCode = mergeScalar(existing.countryCode, row.countryCode);
     existing.displayName = mergeScalar(existing.displayName, row.displayName);
@@ -128,7 +125,10 @@ export function mergeStagedResources(
       existing.managementLevelGroupName,
       row.managementLevelGroupName,
     );
-    existing.managementLevelName = mergeScalar(existing.managementLevelName, row.managementLevelName);
+    existing.managementLevelName = mergeScalar(
+      existing.managementLevelName,
+      row.managementLevelName,
+    );
     existing.metroCityName = mergeScalar(existing.metroCityName, row.metroCityName);
     existing.resourceType = mergeScalar(existing.resourceType, row.resourceType);
     existing.ucrCents = mergeScalar(existing.ucrCents, row.ucrCents);
@@ -194,27 +194,22 @@ export function buildReferenceDataMaps(data: {
     clientIdByCode: new Map(
       data.clients.filter((client) => client.code).map((client) => [client.code!, client.id]),
     ),
-    clientIdByName: new Map(
-      data.clients.map((client) => [client.name.toLowerCase(), client.id]),
-    ),
-    countryIdByCode: new Map(
-      data.countries.map((country) => [country.code, country.id]),
-    ),
+    clientIdByName: new Map(data.clients.map((client) => [client.name.toLowerCase(), client.id])),
+    countryIdByCode: new Map(data.countries.map((country) => [country.code, country.id])),
     managementLevelGroupByName: new Map(
       data.managementLevelGroups.map((group) => [group.name, group]),
     ),
-    managementLevelIdByName: new Map(
-      data.managementLevels.map((level) => [level.name, level.id]),
-    ),
+    managementLevelIdByName: new Map(data.managementLevels.map((level) => [level.name, level.id])),
     metroCityIdByName: new Map(
       data.metroCities.map((metroCity) => [metroCity.name.toLowerCase(), metroCity.id]),
     ),
     orgUnitIdByLevelAndName: new Map(
-      data.orgUnits.map((orgUnit) => [`${orgUnit.level}:${orgUnit.name.toLowerCase()}`, orgUnit.id]),
-    ),
-    roleIdByName: new Map(
-      data.roles.map((role) => [role.name, role.id]),
+      data.orgUnits.map((orgUnit) => [
+        `${orgUnit.level}:${orgUnit.name.toLowerCase()}`,
+        orgUnit.id,
+      ]),
     ),
+    roleIdByName: new Map(data.roles.map((role) => [role.name, role.id])),
     utilizationCategoryIdByCode: new Map(
       data.utilizationCategories.map((category) => [category.code, category.id]),
     ),

packages/application/src/use-cases/dispo-import/commit-dispo-batch-types.ts

@@ -1,4 +1,4 @@
-import type { Prisma, PrismaClient } from "@capakraken/db";
+import type { Prisma, PrismaClient } from "@nexus/db";
 
 export type CommitDbClient = Pick<
   PrismaClient,
@@ -44,7 +44,9 @@ export interface MergedStagedResource {
   managementLevelName: string | null;
   metroCityName: string | null;
   rawPayload: Record<string, unknown>;
-  resourceType: NonNullable<Awaited<ReturnType<TxClient["stagedResource"]["findMany"]>>[number]["resourceType"]> | null;
+  resourceType: NonNullable<
+    Awaited<ReturnType<TxClient["stagedResource"]["findMany"]>>[number]["resourceType"]
+  > | null;
   roleTokens: Set<string>;
   sourceKinds: string[];
   ucrCents: number | null;

packages/application/src/use-cases/dispo-import/commit-dispo-import-batch.ts

@@ -2,20 +2,16 @@ import {
   DISPO_REQUIRED_ROLE_SEEDS,
   DISPO_UTILIZATION_CATEGORIES,
   normalizeDispoRoleToken,
-} from "@capakraken/shared";
-import type { Prisma } from "@capakraken/db";
+} from "@nexus/shared";
+import type { Prisma } from "@nexus/db";
 import {
   AllocationStatus,
   ImportBatchStatus,
   ProjectStatus,
   StagedRecordStatus,
   VacationStatus,
-} from "@capakraken/db";
-import {
-  buildBatchSummaryEntry,
-  buildFallbackAccentureEmail,
-  toJsonObject,
-} from "./shared.js";
+} from "@nexus/db";
+import { buildBatchSummaryEntry, buildFallbackAccentureEmail, toJsonObject } from "./shared.js";
 import { recomputeResourceValueScores } from "../resource/recompute-resource-value-scores.js";
 import { classifyDispoProject } from "./tbd-projects.js";
 import type { CommitDbClient, MergedStagedResource, TxClient } from "./commit-dispo-batch-types.js";
@@ -27,10 +23,7 @@ import {
   mergeStagedResources,
   parseWeekdayAvailability,
 } from "./build-dispo-maps.js";
-import {
-  aggregateAssignments,
-  deriveOverlayAvailability,
-} from "./determine-placement.js";
+import { aggregateAssignments, deriveOverlayAvailability } from "./determine-placement.js";
 
 export interface CommitDispoImportBatchInput {
   allowTbdUnresolved?: boolean;
@@ -147,14 +140,20 @@ function buildResourceData(
     chapter: resource.chapter,
     chargeabilityTarget: resource.chargeabilityTarget ?? defaultChargeabilityTarget,
     clientUnitId: resource.clientUnitName
-      ? (maps.clientIdByCode.get(resource.clientUnitName) ?? maps.clientIdByName.get(resource.clientUnitName.toLowerCase()) ?? null)
+      ? (maps.clientIdByCode.get(resource.clientUnitName) ??
+        maps.clientIdByName.get(resource.clientUnitName.toLowerCase()) ??
+        null)
+      : null,
+    countryId: resource.countryCode
+      ? (maps.countryIdByCode.get(resource.countryCode) ?? null)
       : null,
-    countryId: resource.countryCode ? (maps.countryIdByCode.get(resource.countryCode) ?? null) : null,
     displayName: resource.displayName ?? resource.canonicalExternalId,
     email: resource.email ?? buildFallbackAccentureEmail(resource.canonicalExternalId),
     fte: resource.fte ?? 1,
     lcrCents: resource.lcrCents ?? 0,
-    managementLevelGroupId: resource.managementLevelGroupName ? (managementGroup?.id ?? null) : null,
+    managementLevelGroupId: resource.managementLevelGroupName
+      ? (managementGroup?.id ?? null)
+      : null,
     managementLevelId: resource.managementLevelName
       ? (maps.managementLevelIdByName.get(resource.managementLevelName) ?? null)
       : null,
@@ -291,7 +290,13 @@ async function commitResources(
     }
   }
 
-  return { resourceIdByKey, resourceRoleNameByKey, updatedEntitlements, updatedResourceAvailabilities, upsertedResourceRoles };
+  return {
+    resourceIdByKey,
+    resourceRoleNameByKey,
+    updatedEntitlements,
+    updatedResourceAvailabilities,
+    upsertedResourceRoles,
+  };
 }
 
 async function commitProjects(
@@ -326,7 +331,9 @@ async function commitProjects(
       update: {
         allocationType: stagedProject.allocationType ?? classification.allocationType,
         budgetCents: 0,
-        clientId: stagedProject.clientCode ? (maps.clientIdByCode.get(stagedProject.clientCode) ?? null) : null,
+        clientId: stagedProject.clientCode
+          ? (maps.clientIdByCode.get(stagedProject.clientCode) ?? null)
+          : null,
         dynamicFields,
         endDate: normalizeDate(stagedProject.endDate ?? stagedProject.startDate ?? new Date()),
         name: stagedProject.name ?? shortCode,
@@ -351,7 +358,9 @@ async function commitProjects(
         utilizationCategoryId: stagedProject.utilizationCategoryCode
           ? (maps.utilizationCategoryIdByCode.get(stagedProject.utilizationCategoryCode) ?? null)
           : null,
-        clientId: stagedProject.clientCode ? (maps.clientIdByCode.get(stagedProject.clientCode) ?? null) : null,
+        clientId: stagedProject.clientCode
+          ? (maps.clientIdByCode.get(stagedProject.clientCode) ?? null)
+          : null,
         dynamicFields,
       },
       select: { id: true },
@@ -368,202 +377,266 @@ export async function commitDispoImportBatch(
 ): Promise<CommitDispoImportBatchResult> {
   const validation = await validateDispoBatch(db, input);
 
-  const result = await db.$transaction(async (tx) => {
-    await tx.importBatch.update({
-      where: { id: validation.batchId },
-      data: { status: ImportBatchStatus.COMMITTING },
-    });
-
-    await upsertUtilizationCategories(tx);
-    await upsertRoleSeeds(tx);
-
-    const [
-      stagedResources, stagedProjects, stagedAssignments, stagedVacations,
-      stagedAvailabilityRules, adminUser, countries, metroCities,
-      managementLevelGroups, managementLevels, clients, orgUnits, roles,
-      utilizationCategories,
-    ] = await Promise.all([
-      tx.stagedResource.findMany({ where: { importBatchId: validation.batchId } }),
-      tx.stagedProject.findMany({ where: { importBatchId: validation.batchId } }),
-      tx.stagedAssignment.findMany({ where: { importBatchId: validation.batchId } }),
-      tx.stagedVacation.findMany({ where: { importBatchId: validation.batchId } }),
-      tx.stagedAvailabilityRule.findMany({ where: { importBatchId: validation.batchId } }),
-      tx.user.findFirst({ where: { systemRole: "ADMIN" }, select: { id: true } }),
-      tx.country.findMany({ select: { id: true, code: true } }),
-      tx.metroCity.findMany({ select: { id: true, name: true } }),
-      tx.managementLevelGroup.findMany({ select: { id: true, name: true, targetPercentage: true } }),
-      tx.managementLevel.findMany({ select: { id: true, name: true } }),
-      tx.client.findMany({ select: { id: true, code: true, name: true } }),
-      tx.orgUnit.findMany({ select: { id: true, level: true, name: true } }),
-      tx.role.findMany({ select: { id: true, name: true } }),
-      tx.utilizationCategory.findMany({ select: { id: true, code: true } }),
-    ]);
-
-    if (!adminUser) {
-      throw new Error("Cannot commit Dispo import without an ADMIN user in the database");
-    }
-
-    const maps = buildReferenceDataMaps({
-      clients, countries, managementLevelGroups, managementLevels,
-      metroCities, orgUnits, roles, utilizationCategories,
-    });
-
-    const mergedResources = mergeStagedResources(stagedResources);
-    await ensureInferredRolesExist(tx, mergedResources, maps.roleIdByName);
-
-    const resourceResult = await commitResources(
-      tx, mergedResources, maps, validation.batchId,
-      stagedVacations, stagedAvailabilityRules,
-    );
-
-    const projectIdByShortCode = await commitProjects(
-      tx, stagedProjects, maps, validation.batchId, input.importTbdProjects ?? false,
-    );
-
-    // Commit assignments
-    const aggregatedAssignments = aggregateAssignments(
-      stagedAssignments, resourceResult.resourceIdByKey, projectIdByShortCode,
-      maps.roleIdByName, resourceResult.resourceRoleNameByKey, input.importTbdProjects ?? false,
-    );
-
-    for (const assignment of aggregatedAssignments) {
-      const dailyCostCents = Math.round(
-        assignment.hoursPerDay * (mergedResources.get(assignment.resourceKey)?.lcrCents ?? 0),
-      );
-      const metadata = {
-        dispoImport: {
-          importBatchId: validation.batchId,
-          sourceDates: assignment.sourceDates,
-          utilizationCategoryCode: assignment.utilizationCategoryCode,
-        },
-      } as Prisma.InputJsonValue;
-
-      await tx.assignment.upsert({
-        where: {
-          unique_assignment: {
-            resourceId: assignment.resourceId,
-            projectId: assignment.projectId,
-            startDate: assignment.startDate,
-            endDate: assignment.endDate,
-          },
-        },
-        update: {
-          dailyCostCents, metadata,
-          percentage: assignment.percentage,
-          role: assignment.roleName,
-          roleId: assignment.roleId,
-          status: AllocationStatus.PROPOSED,
-        },
-        create: {
-          dailyCostCents, metadata,
-          endDate: assignment.endDate,
-          hoursPerDay: assignment.hoursPerDay,
-          percentage: assignment.percentage,
-          projectId: assignment.projectId,
-          resourceId: assignment.resourceId,
-          role: assignment.roleName,
-          roleId: assignment.roleId,
-          startDate: assignment.startDate,
-          status: AllocationStatus.PROPOSED,
-        },
+  const result = await db.$transaction(
+    async (tx) => {
+      await tx.importBatch.update({
+        where: { id: validation.batchId },
+        data: { status: ImportBatchStatus.COMMITTING },
       });
 
-      await tx.resourceRole.upsert({
-        where: { resourceId_roleId: { resourceId: assignment.resourceId, roleId: assignment.roleId } },
-        update: {},
-        create: { resourceId: assignment.resourceId, roleId: assignment.roleId },
-      });
-      resourceResult.upsertedResourceRoles += 1;
-    }
+      await upsertUtilizationCategories(tx);
+      await upsertRoleSeeds(tx);
 
-    // Commit vacations
-    for (const stagedVacation of stagedVacations) {
-      const resourceId = resourceResult.resourceIdByKey.get(stagedVacation.resourceExternalId);
-      if (!resourceId) {
-        throw new Error(`Unable to resolve resource "${stagedVacation.resourceExternalId}" during vacation commit`);
+      const [
+        stagedResources,
+        stagedProjects,
+        stagedAssignments,
+        stagedVacations,
+        stagedAvailabilityRules,
+        adminUser,
+        countries,
+        metroCities,
+        managementLevelGroups,
+        managementLevels,
+        clients,
+        orgUnits,
+        roles,
+        utilizationCategories,
+      ] = await Promise.all([
+        tx.stagedResource.findMany({ where: { importBatchId: validation.batchId } }),
+        tx.stagedProject.findMany({ where: { importBatchId: validation.batchId } }),
+        tx.stagedAssignment.findMany({ where: { importBatchId: validation.batchId } }),
+        tx.stagedVacation.findMany({ where: { importBatchId: validation.batchId } }),
+        tx.stagedAvailabilityRule.findMany({ where: { importBatchId: validation.batchId } }),
+        tx.user.findFirst({ where: { systemRole: "ADMIN" }, select: { id: true } }),
+        tx.country.findMany({ select: { id: true, code: true } }),
+        tx.metroCity.findMany({ select: { id: true, name: true } }),
+        tx.managementLevelGroup.findMany({
+          select: { id: true, name: true, targetPercentage: true },
+        }),
+        tx.managementLevel.findMany({ select: { id: true, name: true } }),
+        tx.client.findMany({ select: { id: true, code: true, name: true } }),
+        tx.orgUnit.findMany({ select: { id: true, level: true, name: true } }),
+        tx.role.findMany({ select: { id: true, name: true } }),
+        tx.utilizationCategory.findMany({ select: { id: true, code: true } }),
+      ]);
+
+      if (!adminUser) {
+        throw new Error("Cannot commit Dispo import without an ADMIN user in the database");
       }
 
-      const existing = await tx.vacation.findFirst({
-        where: {
-          endDate: stagedVacation.endDate, halfDayPart: stagedVacation.halfDayPart,
-          isHalfDay: stagedVacation.isHalfDay, note: stagedVacation.note, resourceId,
-          startDate: stagedVacation.startDate, status: VacationStatus.APPROVED,
-          type: stagedVacation.vacationType,
-        },
-        select: { id: true },
+      const maps = buildReferenceDataMaps({
+        clients,
+        countries,
+        managementLevelGroups,
+        managementLevels,
+        metroCities,
+        orgUnits,
+        roles,
+        utilizationCategories,
       });
 
-      if (existing) {
-        await tx.vacation.update({
-          where: { id: existing.id },
-          data: { approvedAt: new Date(), approvedById: adminUser.id, note: stagedVacation.note, requestedById: adminUser.id },
+      const mergedResources = mergeStagedResources(stagedResources);
+      await ensureInferredRolesExist(tx, mergedResources, maps.roleIdByName);
+
+      const resourceResult = await commitResources(
+        tx,
+        mergedResources,
+        maps,
+        validation.batchId,
+        stagedVacations,
+        stagedAvailabilityRules,
+      );
+
+      const projectIdByShortCode = await commitProjects(
+        tx,
+        stagedProjects,
+        maps,
+        validation.batchId,
+        input.importTbdProjects ?? false,
+      );
+
+      // Commit assignments
+      const aggregatedAssignments = aggregateAssignments(
+        stagedAssignments,
+        resourceResult.resourceIdByKey,
+        projectIdByShortCode,
+        maps.roleIdByName,
+        resourceResult.resourceRoleNameByKey,
+        input.importTbdProjects ?? false,
+      );
+
+      for (const assignment of aggregatedAssignments) {
+        const dailyCostCents = Math.round(
+          assignment.hoursPerDay * (mergedResources.get(assignment.resourceKey)?.lcrCents ?? 0),
+        );
+        const metadata = {
+          dispoImport: {
+            importBatchId: validation.batchId,
+            sourceDates: assignment.sourceDates,
+            utilizationCategoryCode: assignment.utilizationCategoryCode,
+          },
+        } as Prisma.InputJsonValue;
+
+        await tx.assignment.upsert({
+          where: {
+            unique_assignment: {
+              resourceId: assignment.resourceId,
+              projectId: assignment.projectId,
+              startDate: assignment.startDate,
+              endDate: assignment.endDate,
+            },
+          },
+          update: {
+            dailyCostCents,
+            metadata,
+            percentage: assignment.percentage,
+            role: assignment.roleName,
+            roleId: assignment.roleId,
+            status: AllocationStatus.PROPOSED,
+          },
+          create: {
+            dailyCostCents,
+            metadata,
+            endDate: assignment.endDate,
+            hoursPerDay: assignment.hoursPerDay,
+            percentage: assignment.percentage,
+            projectId: assignment.projectId,
+            resourceId: assignment.resourceId,
+            role: assignment.roleName,
+            roleId: assignment.roleId,
+            startDate: assignment.startDate,
+            status: AllocationStatus.PROPOSED,
+          },
         });
-      } else {
-        await tx.vacation.create({
-          data: {
-            approvedAt: new Date(), approvedById: adminUser.id,
-            endDate: stagedVacation.endDate, halfDayPart: stagedVacation.halfDayPart,
-            isHalfDay: stagedVacation.isHalfDay, note: stagedVacation.note,
-            requestedById: adminUser.id, resourceId,
-            startDate: stagedVacation.startDate, status: VacationStatus.APPROVED,
+
+        await tx.resourceRole.upsert({
+          where: {
+            resourceId_roleId: { resourceId: assignment.resourceId, roleId: assignment.roleId },
+          },
+          update: {},
+          create: { resourceId: assignment.resourceId, roleId: assignment.roleId },
+        });
+        resourceResult.upsertedResourceRoles += 1;
+      }
+
+      // Commit vacations
+      for (const stagedVacation of stagedVacations) {
+        const resourceId = resourceResult.resourceIdByKey.get(stagedVacation.resourceExternalId);
+        if (!resourceId) {
+          throw new Error(
+            `Unable to resolve resource "${stagedVacation.resourceExternalId}" during vacation commit`,
+          );
+        }
+
+        const existing = await tx.vacation.findFirst({
+          where: {
+            endDate: stagedVacation.endDate,
+            halfDayPart: stagedVacation.halfDayPart,
+            isHalfDay: stagedVacation.isHalfDay,
+            note: stagedVacation.note,
+            resourceId,
+            startDate: stagedVacation.startDate,
+            status: VacationStatus.APPROVED,
             type: stagedVacation.vacationType,
           },
+          select: { id: true },
         });
+
+        if (existing) {
+          await tx.vacation.update({
+            where: { id: existing.id },
+            data: {
+              approvedAt: new Date(),
+              approvedById: adminUser.id,
+              note: stagedVacation.note,
+              requestedById: adminUser.id,
+            },
+          });
+        } else {
+          await tx.vacation.create({
+            data: {
+              approvedAt: new Date(),
+              approvedById: adminUser.id,
+              endDate: stagedVacation.endDate,
+              halfDayPart: stagedVacation.halfDayPart,
+              isHalfDay: stagedVacation.isHalfDay,
+              note: stagedVacation.note,
+              requestedById: adminUser.id,
+              resourceId,
+              startDate: stagedVacation.startDate,
+              status: VacationStatus.APPROVED,
+              type: stagedVacation.vacationType,
+            },
+          });
+        }
       }
-    }
 
-    // Mark staged records as committed
-    await Promise.all([
-      tx.stagedResource.updateMany({ where: { importBatchId: validation.batchId }, data: { status: StagedRecordStatus.COMMITTED } }),
-      tx.stagedProject.updateMany({
-        where: input.importTbdProjects ? { importBatchId: validation.batchId } : { importBatchId: validation.batchId, isTbd: false },
-        data: { status: StagedRecordStatus.COMMITTED },
-      }),
-      tx.stagedAssignment.updateMany({
-        where: input.importTbdProjects
-          ? { importBatchId: validation.batchId, isUnassigned: false }
-          : { importBatchId: validation.batchId, isTbd: false, isUnassigned: false },
-        data: { status: StagedRecordStatus.COMMITTED },
-      }),
-      tx.stagedVacation.updateMany({ where: { importBatchId: validation.batchId }, data: { status: StagedRecordStatus.COMMITTED } }),
-      tx.stagedAvailabilityRule.updateMany({ where: { importBatchId: validation.batchId }, data: { status: StagedRecordStatus.COMMITTED } }),
-    ]);
-
-    await tx.importBatch.update({
-      where: { id: validation.batchId },
-      data: {
-        committedAt: new Date(),
-        status: ImportBatchStatus.COMMITTED,
-        summary: buildBatchSummaryEntry({
-          ...toJsonObject(validation.batchSummary),
-          commit: {
-            committedAssignments: aggregatedAssignments.length,
-            committedProjects: projectIdByShortCode.size,
-            committedResources: mergedResources.size,
-            committedVacations: stagedVacations.length,
-            skippedTbdUnresolved: validation.skippedTbdUnresolved,
-            updatedEntitlements: resourceResult.updatedEntitlements,
-            updatedResourceAvailabilities: resourceResult.updatedResourceAvailabilities,
-            upsertedResourceRoles: resourceResult.upsertedResourceRoles,
-          },
+      // Mark staged records as committed
+      await Promise.all([
+        tx.stagedResource.updateMany({
+          where: { importBatchId: validation.batchId },
+          data: { status: StagedRecordStatus.COMMITTED },
         }),
-      },
-    });
+        tx.stagedProject.updateMany({
+          where: input.importTbdProjects
+            ? { importBatchId: validation.batchId }
+            : { importBatchId: validation.batchId, isTbd: false },
+          data: { status: StagedRecordStatus.COMMITTED },
+        }),
+        tx.stagedAssignment.updateMany({
+          where: input.importTbdProjects
+            ? { importBatchId: validation.batchId, isUnassigned: false }
+            : { importBatchId: validation.batchId, isTbd: false, isUnassigned: false },
+          data: { status: StagedRecordStatus.COMMITTED },
+        }),
+        tx.stagedVacation.updateMany({
+          where: { importBatchId: validation.batchId },
+          data: { status: StagedRecordStatus.COMMITTED },
+        }),
+        tx.stagedAvailabilityRule.updateMany({
+          where: { importBatchId: validation.batchId },
+          data: { status: StagedRecordStatus.COMMITTED },
+        }),
+      ]);
 
-    return {
-      batchId: validation.batchId,
-      counts: {
-        committedAssignments: aggregatedAssignments.length,
-        committedProjects: projectIdByShortCode.size,
-        committedResources: mergedResources.size,
-        committedVacations: stagedVacations.length,
-        updatedEntitlements: resourceResult.updatedEntitlements,
-        updatedResourceAvailabilities: resourceResult.updatedResourceAvailabilities,
-        upsertedResourceRoles: resourceResult.upsertedResourceRoles,
-      },
-      unresolved: { blocked: 0, skippedTbd: validation.skippedTbdUnresolved },
-    } satisfies CommitDispoImportBatchResult;
-  }, { maxWait: 30_000, timeout: 600_000 });
+      await tx.importBatch.update({
+        where: { id: validation.batchId },
+        data: {
+          committedAt: new Date(),
+          status: ImportBatchStatus.COMMITTED,
+          summary: buildBatchSummaryEntry({
+            ...toJsonObject(validation.batchSummary),
+            commit: {
+              committedAssignments: aggregatedAssignments.length,
+              committedProjects: projectIdByShortCode.size,
+              committedResources: mergedResources.size,
+              committedVacations: stagedVacations.length,
+              skippedTbdUnresolved: validation.skippedTbdUnresolved,
+              updatedEntitlements: resourceResult.updatedEntitlements,
+              updatedResourceAvailabilities: resourceResult.updatedResourceAvailabilities,
+              upsertedResourceRoles: resourceResult.upsertedResourceRoles,
+            },
+          }),
+        },
+      });
+
+      return {
+        batchId: validation.batchId,
+        counts: {
+          committedAssignments: aggregatedAssignments.length,
+          committedProjects: projectIdByShortCode.size,
+          committedResources: mergedResources.size,
+          committedVacations: stagedVacations.length,
+          updatedEntitlements: resourceResult.updatedEntitlements,
+          updatedResourceAvailabilities: resourceResult.updatedResourceAvailabilities,
+          upsertedResourceRoles: resourceResult.upsertedResourceRoles,
+        },
+        unresolved: { blocked: 0, skippedTbd: validation.skippedTbdUnresolved },
+      } satisfies CommitDispoImportBatchResult;
+    },
+    { maxWait: 30_000, timeout: 600_000 },
+  );
 
   if ("resource" in db && db.resource) {
     await recomputeResourceValueScores(db);

packages/application/src/use-cases/dispo-import/determine-placement.ts

@@ -1,8 +1,5 @@
-import type { WeekdayAvailability } from "@capakraken/shared";
-import {
-  DISPO_INTERNAL_PROJECT_BUCKETS,
-  normalizeDispoRoleToken,
-} from "@capakraken/shared";
+import type { WeekdayAvailability } from "@nexus/shared";
+import { DISPO_INTERNAL_PROJECT_BUCKETS, normalizeDispoRoleToken } from "@nexus/shared";
 import type { TxClient, AggregatedAssignment } from "./commit-dispo-batch-types.js";
 import { deriveTbdDispoProjectIdentity } from "./tbd-projects.js";
 
@@ -30,7 +27,15 @@ function roundToOneDecimal(value: number): number {
   return Math.round(value * 10) / 10;
 }
 
-const WEEKDAY_KEYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"] as const;
+const WEEKDAY_KEYS = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+] as const;
 const WORKDAY_KEYS = ["monday", "tuesday", "wednesday", "thursday", "friday"] as const;
 
 function resolveInternalProjectShortCode(utilizationCategoryCode: string | null): string | null {
@@ -56,9 +61,9 @@ export function aggregateAssignments(
         ? resolveInternalProjectShortCode(row.utilizationCategoryCode)
         : row.isTbd
           ? deriveTbdDispoProjectIdentity(
-            String(asObject(row.rawPayload).rawToken ?? ""),
-            row.utilizationCategoryCode ?? null,
-          ).shortCode
+              String(asObject(row.rawPayload).rawToken ?? ""),
+              row.utilizationCategoryCode ?? null,
+            ).shortCode
           : (row.projectKey ?? null);
       const roleName =
         row.roleName ??
@@ -70,7 +75,9 @@ export function aggregateAssignments(
       const roleId = roleName ? roleIdByName.get(roleName) : null;
 
       if (!resourceId) {
-        throw new Error(`Unable to resolve resource "${row.resourceExternalId}" during assignment commit`);
+        throw new Error(
+          `Unable to resolve resource "${row.resourceExternalId}" during assignment commit`,
+        );
       }
       if (!projectShortCode || !projectId) {
         throw new Error(
@@ -83,7 +90,9 @@ export function aggregateAssignments(
         );
       }
       if (row.assignmentDate === null || row.hoursPerDay === null || row.percentage === null) {
-        throw new Error(`Assignment row "${row.id}" is missing normalized date or load information`);
+        throw new Error(
+          `Assignment row "${row.id}" is missing normalized date or load information`,
+        );
       }
 
       return {
@@ -99,18 +108,20 @@ export function aggregateAssignments(
         utilizationCategoryCode: row.utilizationCategoryCode ?? null,
       };
     })
-    .sort((left, right) =>
-      left.resourceKey.localeCompare(right.resourceKey) ||
-      left.projectShortCode.localeCompare(right.projectShortCode) ||
-      left.roleName.localeCompare(right.roleName) ||
-      left.assignmentDate.getTime() - right.assignmentDate.getTime(),
+    .sort(
+      (left, right) =>
+        left.resourceKey.localeCompare(right.resourceKey) ||
+        left.projectShortCode.localeCompare(right.projectShortCode) ||
+        left.roleName.localeCompare(right.roleName) ||
+        left.assignmentDate.getTime() - right.assignmentDate.getTime(),
     );
 
   const aggregated: AggregatedAssignment[] = [];
 
   for (const row of resolvedRows) {
     const previous = aggregated.at(-1);
-    const canMerge = previous &&
+    const canMerge =
+      previous &&
       previous.resourceId === row.resourceId &&
       previous.projectId === row.projectId &&
       previous.roleId === row.roleId &&
@@ -163,11 +174,11 @@ export function deriveOverlayAvailability(
     if (!weekdayKey || !WORKDAY_KEYS.includes(weekdayKey)) {
       continue;
     }
-    const availableHours = rule.availableHours ?? (
-      rule.percentage !== null && rule.percentage !== undefined
+    const availableHours =
+      rule.availableHours ??
+      (rule.percentage !== null && rule.percentage !== undefined
         ? roundToOneDecimal((rule.percentage / 100) * 8)
-        : null
-    );
+        : null);
     if (availableHours === null) {
       continue;
     }

packages/application/src/use-cases/dispo-import/parse-chargeability-workbook.ts

@@ -1,5 +1,21 @@
-import { DispoStagedRecordType } from "@capakraken/db";
-import { DISPO_CHARGEABILITY_SHEET, type ParsedChargeabilityResource, type ParsedChargeabilityWorkbook, type ParsedUnresolvedRecord, buildFallbackAccentureEmail, createAvailabilityFromFte, deriveCountryCodeFromMetroCity, deriveDisplayNameFromEnterpriseId, deriveNormalizedChapter, deriveRoleTokens, ensurePercentageValue, mapChargeabilityResourceType, normalizeNullableWorkbookValue, normalizeText, resolveCanonicalEnterpriseIdentity } from "./shared.js";
+import { DispoStagedRecordType } from "@nexus/db";
+import {
+  DISPO_CHARGEABILITY_SHEET,
+  type ParsedChargeabilityResource,
+  type ParsedChargeabilityWorkbook,
+  type ParsedUnresolvedRecord,
+  buildFallbackAccentureEmail,
+  createAvailabilityFromFte,
+  deriveCountryCodeFromMetroCity,
+  deriveDisplayNameFromEnterpriseId,
+  deriveNormalizedChapter,
+  deriveRoleTokens,
+  ensurePercentageValue,
+  mapChargeabilityResourceType,
+  normalizeNullableWorkbookValue,
+  normalizeText,
+  resolveCanonicalEnterpriseIdentity,
+} from "./shared.js";
 import { readWorksheetMatrix } from "./read-workbook.js";
 
 const CHGFC_HEADERS = {
@@ -107,9 +123,10 @@ export async function parseDispoChargeabilityWorkbook(
       getCellValue(row, headerMap, CHGFC_HEADERS.managementLevelGroup),
     );
     const rawTarget = getCellValue(row, headerMap, CHGFC_HEADERS.target);
-    const fte = typeof getCellValue(row, headerMap, CHGFC_HEADERS.fte) === "number"
-      ? Number(getCellValue(row, headerMap, CHGFC_HEADERS.fte))
-      : null;
+    const fte =
+      typeof getCellValue(row, headerMap, CHGFC_HEADERS.fte) === "number"
+        ? Number(getCellValue(row, headerMap, CHGFC_HEADERS.fte))
+        : null;
     const metroCityName = normalizeNullableWorkbookValue(
       getCellValue(row, headerMap, CHGFC_HEADERS.metroCity),
     );
@@ -170,7 +187,9 @@ export async function parseDispoChargeabilityWorkbook(
       continue;
     }
 
-    existing.warnings.push(`Conflicting duplicate ChgFC row ${rowNumber} found for ${canonicalExternalId}`);
+    existing.warnings.push(
+      `Conflicting duplicate ChgFC row ${rowNumber} found for ${canonicalExternalId}`,
+    );
     unresolved.push({
       sourceRow: rowNumber,
       sourceColumn: "A",

packages/application/src/use-cases/dispo-import/parse-dispo-matrix.ts

@@ -1,10 +1,10 @@
-import { DispoStagedRecordType } from "@capakraken/db";
+import { DispoStagedRecordType } from "@nexus/db";
 import {
   VacationType,
   normalizeCanonicalResourceIdentity,
   normalizeDispoRoleToken,
   normalizeDispoUtilizationToken,
-} from "@capakraken/shared";
+} from "@nexus/shared";
 import { readWorksheetMatrix, toColumnLetter, type WorksheetCellValue } from "./read-workbook.js";
 import {
   DISPO_PLANNING_SHEET,
@@ -182,27 +182,37 @@ function isPlanningSummaryRow(row: ReadonlyArray<WorksheetCellValue>): boolean {
   const normalizedLabels = new Set(repeatedLabels.map((value) => value.toLowerCase()));
   const label = repeatedLabels[0] ?? null;
 
-  return normalizedLabels.size === 1 && label !== null && label.startsWith("(") && label.endsWith(")");
+  return (
+    normalizedLabels.size === 1 && label !== null && label.startsWith("(") && label.endsWith(")")
+  );
 }
 
 function buildPlanningColumns(rows: ReadonlyArray<ReadonlyArray<WorksheetCellValue>>) {
   const columns: PlanningColumn[] = [];
-  const headerWidth = Math.max(rows[DISPO_DATE_ROW - 1]?.length ?? 0, rows[DISPO_SLOT_ROW - 1]?.length ?? 0);
+  const headerWidth = Math.max(
+    rows[DISPO_DATE_ROW - 1]?.length ?? 0,
+    rows[DISPO_SLOT_ROW - 1]?.length ?? 0,
+  );
 
-  for (let columnNumber = DISPO_PLANNING_START_COLUMN; columnNumber <= headerWidth; columnNumber += 1) {
+  for (
+    let columnNumber = DISPO_PLANNING_START_COLUMN;
+    columnNumber <= headerWidth;
+    columnNumber += 1
+  ) {
     const slotLabel = normalizeNullableWorkbookValue(rows[DISPO_SLOT_ROW - 1]?.[columnNumber - 1]);
     if (!slotLabel) {
       continue;
     }
 
     const currentHeaderValue = rows[DISPO_DATE_ROW - 1]?.[columnNumber - 1] ?? null;
-    const previousHeaderLabel = normalizeNullableWorkbookValue(rows[DISPO_DATE_ROW - 1]?.[columnNumber - 2]);
+    const previousHeaderLabel = normalizeNullableWorkbookValue(
+      rows[DISPO_DATE_ROW - 1]?.[columnNumber - 2],
+    );
     const currentHeaderLabel = normalizeNullableWorkbookValue(currentHeaderValue);
     const nextHeaderValue = rows[DISPO_DATE_ROW - 1]?.[columnNumber] ?? null;
 
     const assignmentDate =
-      toDateOnlyInBerlin(currentHeaderValue) ??
-      toDateOnlyInBerlin(nextHeaderValue);
+      toDateOnlyInBerlin(currentHeaderValue) ?? toDateOnlyInBerlin(nextHeaderValue);
 
     if (!assignmentDate) {
       continue;
@@ -236,10 +246,15 @@ function normalizePlanningToken(token: string): string {
 }
 
 function extractBracketTokens(token: string): string[] {
-  return Array.from(token.matchAll(/\[([^\]]+)\]/g), (match) => match[1]?.trim() ?? "").filter(Boolean);
+  return Array.from(token.matchAll(/\[([^\]]+)\]/g), (match) => match[1]?.trim() ?? "").filter(
+    Boolean,
+  );
 }
 
-function extractUtilizationToken(token: string): { utilizationToken: string | null; winProbability: number | null } {
+function extractUtilizationToken(token: string): {
+  utilizationToken: string | null;
+  winProbability: number | null;
+} {
   const matches = Array.from(token.matchAll(/\{([A-Z]+)(\d{0,3})\}/gi));
   const lastMatch = matches.at(-1);
   if (!lastMatch) {
@@ -263,7 +278,9 @@ function extractRoleToken(token: string, metadata: PlanningRowMetadata): string
     return explicitRoleToken;
   }
 
-  return deriveRoleTokens(metadata.chapter, metadata.typeOfWork, metadata.unitSpecificField)[0] ?? null;
+  return (
+    deriveRoleTokens(metadata.chapter, metadata.typeOfWork, metadata.unitSpecificField)[0] ?? null
+  );
 }
 
 function extractProjectKey(token: string): string | null {
@@ -466,9 +483,10 @@ function buildAvailabilityAccumulator(
   } = {},
 ): AvailabilityAccumulator {
   const percentage = input.percentage ?? parsePercentage(rawToken);
-  const availableHours = percentage !== null
-    ? Math.round((percentage / 100) * 8 * 100) / 100
-    : (input.availableHours ?? (8 - SLOT_HOURS));
+  const availableHours =
+    percentage !== null
+      ? Math.round((percentage / 100) * 8 * 100) / 100
+      : (input.availableHours ?? 8 - SLOT_HOURS);
   const warnings = new Set<string>();
   if (input.warning) {
     warnings.add(input.warning);
@@ -548,7 +566,9 @@ export async function parseDispoPlanningWorkbook(
 
       if (normalizedToken.startsWith("[_AB]")) {
         const note = extractLabel(rawToken);
-        const vacationType = note?.toLowerCase().includes("sick") ? VacationType.SICK : VacationType.ANNUAL;
+        const vacationType = note?.toLowerCase().includes("sick")
+          ? VacationType.SICK
+          : VacationType.ANNUAL;
         const key = `${metadata.eid}|${getDateKey(column.assignmentDate)}|VAC|${rawToken}`;
         const existing = vacations.get(key);
         if (existing) {
@@ -577,11 +597,17 @@ export async function parseDispoPlanningWorkbook(
             existing.halfDayParts.add(column.halfDayPart);
           }
         } else {
-          const vacation = buildVacationAccumulator(column, metadata, rawToken, VacationType.PUBLIC_HOLIDAY, {
-            holidayName,
-            isPublicHoliday: true,
-            note: holidayName,
-          });
+          const vacation = buildVacationAccumulator(
+            column,
+            metadata,
+            rawToken,
+            VacationType.PUBLIC_HOLIDAY,
+            {
+              holidayName,
+              isPublicHoliday: true,
+              note: holidayName,
+            },
+          );
           vacation.sourceRow = rowNumber;
           vacations.set(key, vacation);
         }
@@ -595,7 +621,9 @@ export async function parseDispoPlanningWorkbook(
         const existing = availabilityRules.get(key);
         if (existing) {
           const nextAvailability = buildAvailabilityAccumulator(column, metadata, rawToken, {
-            ...(naHandling.availableHours !== undefined ? { availableHours: naHandling.availableHours } : {}),
+            ...(naHandling.availableHours !== undefined
+              ? { availableHours: naHandling.availableHours }
+              : {}),
             ...(naHandling.percentage !== undefined ? { percentage: naHandling.percentage } : {}),
             ...(naHandling.ruleType !== undefined ? { ruleType: naHandling.ruleType } : {}),
             ...(naHandling.warning !== undefined ? { warning: naHandling.warning } : {}),
@@ -607,7 +635,9 @@ export async function parseDispoPlanningWorkbook(
           }
         } else {
           const availabilityRule = buildAvailabilityAccumulator(column, metadata, rawToken, {
-            ...(naHandling.availableHours !== undefined ? { availableHours: naHandling.availableHours } : {}),
+            ...(naHandling.availableHours !== undefined
+              ? { availableHours: naHandling.availableHours }
+              : {}),
             ...(naHandling.percentage !== undefined ? { percentage: naHandling.percentage } : {}),
             ...(naHandling.ruleType !== undefined ? { ruleType: naHandling.ruleType } : {}),
             ...(naHandling.warning !== undefined ? { warning: naHandling.warning } : {}),
@@ -673,7 +703,8 @@ export async function parseDispoPlanningWorkbook(
           resourceExternalId: metadata.eid,
           projectKey: null,
           message: `Unable to resolve project key from planning token "${rawToken}"`,
-          resolutionHint: "Add a WBS token or classify this cell as an internal bucket before commit",
+          resolutionHint:
+            "Add a WBS token or classify this cell as an internal bucket before commit",
           warnings: Array.from(assignment.warnings),
           normalizedData: {
             assignmentDate: getDateKey(column.assignmentDate),
@@ -716,30 +747,32 @@ export async function parseDispoPlanningWorkbook(
     }
   }
 
-  const parsedAssignments: ParsedPlanningAssignment[] = Array.from(assignments.values()).map((entry) => ({
-    assignmentDate: entry.assignmentDate,
-    chapterToken: entry.chapterToken,
-    hoursPerDay: entry.hoursPerDay,
-    isInternal: entry.isInternal,
-    isTbd: entry.isTbd,
-    isUnassigned: entry.isUnassigned,
-    percentage: entry.slotCount * 50,
-    projectKey: entry.projectKey,
-    rawToken: entry.rawToken,
-    resourceExternalId: entry.resourceExternalId,
-    roleName: entry.roleName,
-    roleToken: entry.roleToken,
-    slotFraction: entry.slotCount / 2,
-    sourceColumn: toColumnLetter(entry.firstColumnNumber),
-    sourceRow: entry.sourceRow,
-    utilizationCategoryCode: entry.utilizationCategoryCode,
-    warnings: Array.from(entry.warnings),
-    winProbability: entry.winProbability,
-  }));
+  const parsedAssignments: ParsedPlanningAssignment[] = Array.from(assignments.values()).map(
+    (entry) => ({
+      assignmentDate: entry.assignmentDate,
+      chapterToken: entry.chapterToken,
+      hoursPerDay: entry.hoursPerDay,
+      isInternal: entry.isInternal,
+      isTbd: entry.isTbd,
+      isUnassigned: entry.isUnassigned,
+      percentage: entry.slotCount * 50,
+      projectKey: entry.projectKey,
+      rawToken: entry.rawToken,
+      resourceExternalId: entry.resourceExternalId,
+      roleName: entry.roleName,
+      roleToken: entry.roleToken,
+      slotFraction: entry.slotCount / 2,
+      sourceColumn: toColumnLetter(entry.firstColumnNumber),
+      sourceRow: entry.sourceRow,
+      utilizationCategoryCode: entry.utilizationCategoryCode,
+      warnings: Array.from(entry.warnings),
+      winProbability: entry.winProbability,
+    }),
+  );
 
   const parsedVacations: ParsedPlanningVacation[] = Array.from(vacations.values()).map((entry) => ({
     endDate: entry.endDate,
-    halfDayPart: entry.halfDayParts.size === 1 ? Array.from(entry.halfDayParts)[0] ?? null : null,
+    halfDayPart: entry.halfDayParts.size === 1 ? (Array.from(entry.halfDayParts)[0] ?? null) : null,
     holidayName: entry.holidayName,
     isHalfDay: entry.halfDayParts.size === 1,
     isPublicHoliday: entry.isPublicHoliday,
@@ -753,7 +786,9 @@ export async function parseDispoPlanningWorkbook(
     warnings: Array.from(entry.warnings),
   }));
 
-  const parsedAvailabilityRules: ParsedPlanningAvailabilityRule[] = Array.from(availabilityRules.values()).map((entry) => ({
+  const parsedAvailabilityRules: ParsedPlanningAvailabilityRule[] = Array.from(
+    availabilityRules.values(),
+  ).map((entry) => ({
     availableHours: entry.availableHours,
     effectiveEndDate: entry.effectiveEndDate,
     effectiveStartDate: entry.effectiveStartDate,

packages/application/src/use-cases/dispo-import/parse-dispo-roster-workbook.ts

@@ -1,5 +1,5 @@
-import { DispoStagedRecordType, ResourceType } from "@capakraken/db";
-import { createWeekdayAvailabilityFromFte } from "@capakraken/shared";
+import { DispoStagedRecordType, ResourceType } from "@nexus/db";
+import { createWeekdayAvailabilityFromFte } from "@nexus/shared";
 import {
   parseResourceRosterMasterWorkbook,
   type ParsedResourceRosterLevelAverage,
@@ -291,7 +291,9 @@ export async function parseDispoRosterWorkbook(
 
   for (let rowNumber = 2; rowNumber <= rosterRows.length; rowNumber += 1) {
     const row = rosterRows[rowNumber - 1] ?? [];
-    const eidValue = normalizeNullableWorkbookValue(getCellValue(row, rosterHeaderMap, ROSTER_HEADERS.eid));
+    const eidValue = normalizeNullableWorkbookValue(
+      getCellValue(row, rosterHeaderMap, ROSTER_HEADERS.eid),
+    );
     if (!eidValue) {
       if (row.some((value) => normalizeText(value) !== null)) {
         warnings.push(`Ignoring DispoRoster row ${rowNumber} because EID is missing`);
@@ -423,9 +425,10 @@ export async function parseDispoRosterWorkbook(
       employeeName: normalizeNullableWorkbookValue(
         getCellValue(row, sapHeaderMap, SAP_HEADERS.employeeName),
       ),
-      employeeEmail: normalizeNullableWorkbookValue(
-        getCellValue(row, sapHeaderMap, SAP_HEADERS.employeeEmail),
-      )?.toLowerCase() ?? null,
+      employeeEmail:
+        normalizeNullableWorkbookValue(
+          getCellValue(row, sapHeaderMap, SAP_HEADERS.employeeEmail),
+        )?.toLowerCase() ?? null,
       metroCityName: normalizeNullableWorkbookValue(
         getCellValue(row, sapHeaderMap, SAP_HEADERS.metroCity),
       ),
@@ -472,15 +475,19 @@ export async function parseDispoRosterWorkbook(
       normalizeSapDisplayName(sap?.employeeName ?? null) ??
       deriveDisplayNameFromEnterpriseId(canonicalExternalId);
     const metroCityName = sap?.metroCityName ?? roster?.metroCityName ?? null;
-    const managementLevelName =
-      sap?.managementLevelName ?? roster?.managementLevelName ?? null;
-    const resourceWarnings = buildResourceWarnings(resourceType, resourceTypeResult.warning, roster, sap);
+    const managementLevelName = sap?.managementLevelName ?? roster?.managementLevelName ?? null;
+    const resourceWarnings = buildResourceWarnings(
+      resourceType,
+      resourceTypeResult.warning,
+      roster,
+      sap,
+    );
     const rateResolution = applyRateResolution({
       canonicalExternalId,
       level: managementLevelName,
       rateRecord: rateWorkbook?.rates.get(canonicalExternalId) ?? null,
       levelAverage: managementLevelName
-        ? rateWorkbook?.levelAverages.get(managementLevelName) ?? null
+        ? (rateWorkbook?.levelAverages.get(managementLevelName) ?? null)
         : null,
       warnings: resourceWarnings,
     });
@@ -495,7 +502,8 @@ export async function parseDispoRosterWorkbook(
       email: sap?.employeeEmail ?? buildFallbackAccentureEmail(canonicalExternalId),
       chapter: normalizedChapter.chapter,
       chapterCode: normalizedChapter.chapterCode,
-      managementLevelGroupName: sap?.managementLevelGroupName ?? roster?.managementLevelGroupName ?? null,
+      managementLevelGroupName:
+        sap?.managementLevelGroupName ?? roster?.managementLevelGroupName ?? null,
       managementLevelName,
       countryCode: deriveCountryCodeFromMetroCity(metroCityName),
       metroCityName,
@@ -547,7 +555,9 @@ export async function parseDispoRosterWorkbook(
     warnings.push(`Ignored ${ignoredPseudoDemandRows} pseudo-demand rows from DispoRoster`);
   }
 
-  resources.sort((left, right) => left.canonicalExternalId.localeCompare(right.canonicalExternalId));
+  resources.sort((left, right) =>
+    left.canonicalExternalId.localeCompare(right.canonicalExternalId),
+  );
 
   return {
     excludedCanonicalExternalIds: Array.from(excludedCanonicalExternalIds).sort((left, right) =>

packages/application/src/use-cases/dispo-import/parse-resource-roster-master-workbook.ts

@@ -1,4 +1,4 @@
-import { normalizeCanonicalResourceIdentity } from "@capakraken/shared";
+import { normalizeCanonicalResourceIdentity } from "@nexus/shared";
 import { readWorksheetMatrix } from "./read-workbook.js";
 import { normalizeNullableWorkbookValue, normalizeText } from "./shared.js";
 

packages/application/src/use-cases/dispo-import/shared.ts

@@ -1,17 +1,17 @@
 import path from "node:path";
-import type { Prisma, PrismaClient } from "@capakraken/db";
+import type { Prisma, PrismaClient } from "@nexus/db";
 import {
   DispoImportSourceKind,
   DispoStagedRecordType,
   ImportBatchStatus,
   ResourceType,
   StagedRecordStatus,
-} from "@capakraken/db";
+} from "@nexus/db";
 import {
   createWeekdayAvailabilityFromFte,
   normalizeCanonicalResourceIdentity,
   normalizeDispoChapterToken,
-} from "@capakraken/shared";
+} from "@nexus/shared";
 
 export type DispoImportDbClient = Pick<
   PrismaClient,

packages/application/src/use-cases/dispo-import/stage-chargeability-resources.ts

@@ -1,7 +1,13 @@
-import type { Prisma } from "@capakraken/db";
-import { DispoImportSourceKind, StagedRecordStatus } from "@capakraken/db";
+import type { Prisma } from "@nexus/db";
+import { DispoImportSourceKind, StagedRecordStatus } from "@nexus/db";
 import { parseDispoChargeabilityWorkbook } from "./parse-chargeability-workbook.js";
-import { ensureImportBatch, finalizeImportBatchStage, getWorkbookFileName, type DispoChargeabilityImportInput, type DispoImportDbClient } from "./shared.js";
+import {
+  ensureImportBatch,
+  finalizeImportBatchStage,
+  getWorkbookFileName,
+  type DispoChargeabilityImportInput,
+  type DispoImportDbClient,
+} from "./shared.js";
 
 export interface StageDispoChargeabilityResourcesResult {
   batchId: string;
@@ -53,9 +59,8 @@ export async function stageDispoChargeabilityResources(
     await db.stagedResource.createMany({
       data: filteredResources.map((resource) => ({
         importBatchId: batch.id,
-        status: resource.warnings.length > 0
-          ? StagedRecordStatus.PARSED
-          : StagedRecordStatus.NORMALIZED,
+        status:
+          resource.warnings.length > 0 ? StagedRecordStatus.PARSED : StagedRecordStatus.NORMALIZED,
         sourceKind: DispoImportSourceKind.CHARGEABILITY,
         sourceWorkbook,
         sourceSheet: "ChgFC",

packages/application/src/use-cases/dispo-import/stage-dispo-planning.ts

@@ -1,5 +1,5 @@
-import type { Prisma } from "@capakraken/db";
-import { DispoImportSourceKind, StagedRecordStatus } from "@capakraken/db";
+import type { Prisma } from "@nexus/db";
+import { DispoImportSourceKind, StagedRecordStatus } from "@nexus/db";
 import { parseDispoPlanningWorkbook } from "./parse-dispo-matrix.js";
 import {
   DISPO_PLANNING_SHEET,
@@ -96,9 +96,10 @@ export async function stageDispoPlanningData(
     await db.stagedAssignment.createMany({
       data: filteredAssignments.map((assignment) => ({
         importBatchId: batch.id,
-        status: assignment.warnings.length > 0
-          ? StagedRecordStatus.PARSED
-          : StagedRecordStatus.NORMALIZED,
+        status:
+          assignment.warnings.length > 0
+            ? StagedRecordStatus.PARSED
+            : StagedRecordStatus.NORMALIZED,
         sourceKind: DispoImportSourceKind.PLANNING,
         sourceWorkbook,
         sourceSheet: DISPO_PLANNING_SHEET,
@@ -141,9 +142,8 @@ export async function stageDispoPlanningData(
     await db.stagedVacation.createMany({
       data: filteredVacations.map((vacation) => ({
         importBatchId: batch.id,
-        status: vacation.warnings.length > 0
-          ? StagedRecordStatus.PARSED
-          : StagedRecordStatus.NORMALIZED,
+        status:
+          vacation.warnings.length > 0 ? StagedRecordStatus.PARSED : StagedRecordStatus.NORMALIZED,
         sourceKind: DispoImportSourceKind.PLANNING,
         sourceWorkbook,
         sourceSheet: DISPO_PLANNING_SHEET,
@@ -176,9 +176,8 @@ export async function stageDispoPlanningData(
     await db.stagedAvailabilityRule.createMany({
       data: filteredAvailabilityRules.map((rule) => ({
         importBatchId: batch.id,
-        status: rule.warnings.length > 0
-          ? StagedRecordStatus.PARSED
-          : StagedRecordStatus.NORMALIZED,
+        status:
+          rule.warnings.length > 0 ? StagedRecordStatus.PARSED : StagedRecordStatus.NORMALIZED,
         sourceKind: DispoImportSourceKind.PLANNING,
         sourceWorkbook,
         sourceSheet: DISPO_PLANNING_SHEET,

packages/application/src/use-cases/dispo-import/stage-dispo-projects.ts

@@ -1,6 +1,6 @@
-import type { Prisma } from "@capakraken/db";
-import { AllocationType, DispoImportSourceKind, OrderType, StagedRecordStatus } from "@capakraken/db";
-import { DISPO_INTERNAL_PROJECT_BUCKETS } from "@capakraken/shared";
+import type { Prisma } from "@nexus/db";
+import { AllocationType, DispoImportSourceKind, OrderType, StagedRecordStatus } from "@nexus/db";
+import { DISPO_INTERNAL_PROJECT_BUCKETS } from "@nexus/shared";
 import { parseDispoPlanningWorkbook } from "./parse-dispo-matrix.js";
 import {
   classifyDispoProject,
@@ -113,8 +113,8 @@ export async function stageDispoProjects(
     }
 
     if (assignment.isInternal) {
-      const internalBucket = DISPO_INTERNAL_PROJECT_BUCKETS.find(
-        (bucket) => assignment.rawToken.includes(`{${bucket.sourceToken}}`),
+      const internalBucket = DISPO_INTERNAL_PROJECT_BUCKETS.find((bucket) =>
+        assignment.rawToken.includes(`{${bucket.sourceToken}}`),
       );
       if (!internalBucket) {
         continue;
@@ -227,9 +227,7 @@ export async function stageDispoProjects(
     })
     .map((project) => ({
       importBatchId: batch.id,
-      status: project.warnings.size > 0
-        ? StagedRecordStatus.PARSED
-        : StagedRecordStatus.NORMALIZED,
+      status: project.warnings.size > 0 ? StagedRecordStatus.PARSED : StagedRecordStatus.NORMALIZED,
       sourceKind: DispoImportSourceKind.PLANNING,
       sourceWorkbook,
       sourceSheet: DISPO_PLANNING_SHEET,
@@ -265,7 +263,10 @@ export async function stageDispoProjects(
     });
   }
 
-  const warningCount = stagedProjects.reduce((count, project) => count + project.warnings.length, 0);
+  const warningCount = stagedProjects.reduce(
+    (count, project) => count + project.warnings.length,
+    0,
+  );
   const summary = {
     stagedProjects: stagedProjects.length,
     warnings: warningCount,

packages/application/src/use-cases/dispo-import/stage-dispo-roster-resources.ts

@@ -1,5 +1,5 @@
-import type { Prisma } from "@capakraken/db";
-import { DispoImportSourceKind, StagedRecordStatus } from "@capakraken/db";
+import type { Prisma } from "@nexus/db";
+import { DispoImportSourceKind, StagedRecordStatus } from "@nexus/db";
 import { parseDispoRosterWorkbook } from "./parse-dispo-roster-workbook.js";
 import {
   ensureImportBatch,
@@ -53,9 +53,8 @@ export async function stageDispoRosterResources(
     await db.stagedResource.createMany({
       data: parsed.resources.map((resource) => ({
         importBatchId: batch.id,
-        status: resource.warnings.length > 0
-          ? StagedRecordStatus.PARSED
-          : StagedRecordStatus.NORMALIZED,
+        status:
+          resource.warnings.length > 0 ? StagedRecordStatus.PARSED : StagedRecordStatus.NORMALIZED,
         sourceKind: DispoImportSourceKind.ROSTER,
         sourceWorkbook,
         sourceSheet: resource.sourceSheet,
@@ -131,7 +130,8 @@ export async function stageDispoRosterResources(
         status: StagedRecordStatus.UNRESOLVED,
         sourceKind: DispoImportSourceKind.ROSTER,
         sourceWorkbook,
-        sourceSheet: record.sourceRow >= 3 && record.sourceColumn === "C" ? "SAP_data" : "DispoRoster",
+        sourceSheet:
+          record.sourceRow >= 3 && record.sourceColumn === "C" ? "SAP_data" : "DispoRoster",
         sourceRow: record.sourceRow,
         sourceColumn: record.sourceColumn ?? null,
         recordType: record.recordType,

packages/application/src/use-cases/dispo-import/stage-reference-data.ts

@@ -1,7 +1,14 @@
-import type { Prisma } from "@capakraken/db";
-import { DispoImportSourceKind, StagedRecordStatus } from "@capakraken/db";
+import type { Prisma } from "@nexus/db";
+import { DispoImportSourceKind, StagedRecordStatus } from "@nexus/db";
 import { parseMandatoryDispoReferenceWorkbook } from "./parse-reference-workbook.js";
-import { ensureImportBatch, finalizeImportBatchStage, getWorkbookFileName, type DispoImportDbClient, type DispoReferenceImportInput, toJsonObject } from "./shared.js";
+import {
+  ensureImportBatch,
+  finalizeImportBatchStage,
+  getWorkbookFileName,
+  type DispoImportDbClient,
+  type DispoReferenceImportInput,
+  toJsonObject,
+} from "./shared.js";
 
 async function upsertRootClient(
   db: DispoImportDbClient,

packages/application/src/use-cases/dispo-import/tbd-projects.ts

@@ -1,11 +1,10 @@
 import { createHash } from "node:crypto";
-import { AllocationType, OrderType } from "@capakraken/db";
+import { AllocationType, OrderType } from "@nexus/db";
 
 function extractBracketTokens(token: string): string[] {
-  return Array.from(
-    token.matchAll(/\[([^\]]+)\]/g),
-    (match) => match[1]?.trim() ?? "",
-  ).filter(Boolean);
+  return Array.from(token.matchAll(/\[([^\]]+)\]/g), (match) => match[1]?.trim() ?? "").filter(
+    Boolean,
+  );
 }
 
 function extractClientCode(token: string): string | null {
@@ -39,7 +38,11 @@ function slugifyFragment(value: string): string {
     .replace(/^-+|-+$/g, "");
 }
 
-function shortSegment(value: string | null | undefined, fallback: string, maxLength: number): string {
+function shortSegment(
+  value: string | null | undefined,
+  fallback: string,
+  maxLength: number,
+): string {
   const normalized = slugifyFragment(value ?? "");
   return (normalized.length > 0 ? normalized : fallback).slice(0, maxLength);
 }
@@ -56,7 +59,9 @@ export interface DerivedDispoProjectClassification {
   orderType: OrderType;
 }
 
-export function classifyDispoProject(utilizationCategoryCode: string | null): DerivedDispoProjectClassification {
+export function classifyDispoProject(
+  utilizationCategoryCode: string | null,
+): DerivedDispoProjectClassification {
   if (utilizationCategoryCode === "Chg") {
     return {
       allocationType: AllocationType.EXT,

packages/application/src/use-cases/dispo-import/validate-dispo-batch.ts

@@ -1,5 +1,5 @@
 import type { CommitDbClient } from "./commit-dispo-batch-types.js";
-import { StagedRecordStatus } from "@capakraken/db";
+import { StagedRecordStatus } from "@nexus/db";
 
 function asObject(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" && !Array.isArray(value)
@@ -14,10 +14,9 @@ function isAllowedUnresolvedRecord(
   const hint = (record.resolutionHint ?? "").toLowerCase();
   const rawToken = String(asObject(record.normalizedData).rawToken ?? "").toLowerCase();
 
-  return record.recordType === "PROJECT" && (
-    message.includes("[tbd]") ||
-    hint.includes("[tbd]") ||
-    rawToken.includes("[tbd]")
+  return (
+    record.recordType === "PROJECT" &&
+    (message.includes("[tbd]") || hint.includes("[tbd]") || rawToken.includes("[tbd]"))
   );
 }
 
@@ -46,7 +45,9 @@ export async function validateDispoBatch(
   }
 
   if (!["STAGED", "REVIEW_READY", "APPROVED"].includes(batch.status)) {
-    throw new Error(`Import batch "${batch.id}" is not ready to commit from status "${batch.status}"`);
+    throw new Error(
+      `Import batch "${batch.id}" is not ready to commit from status "${batch.status}"`,
+    );
   }
 
   const unresolved = await db.stagedUnresolvedRecord.findMany({